| slovo | definícia |
modulo
(encz) | modulo,modulo Zdeněk Brož |
modulo
(czen) | modulo,modulo Zdeněk Brož |
modulo
(foldoc) | modulo
/mod'yu-loh/
1. modular arithmetic.
2. modulo operator.
(1999-07-12)
|
modulo
(jargon) | modulo
/mod'yu·loh/, prep.
Except for. An overgeneralization of mathematical terminology; one can
consider saying that 4 equals 22 except for the 9s (4 = 22 mod 9). “Well,
LISP seems to work okay now, modulo that GC bug.” “I feel fine today
modulo a slight headache.”
|
| | podobné slovo | definícia |
demodulovat
(czen) | demodulovat,demodulatev: Zdeněk Brož |
modulovaný
(czen) | modulovaný,modulatedadj: Zdeněk Brož |
modulovat
(czen) | modulovat,modulatev: Zdeněk Brož |
zkratka modulo
(czen) | zkratka modulo,mod Zdeněk Brož |
modulo arithmetic
(foldoc) | modular arithmetic
modulo arithmetic
(Or "clock arithmetic") A kind of integer
arithmetic that reduces all numbers to one of a fixed set
[0..N-1] (this would be "modulo N arithmetic") by effectively
repeatedly adding or subtracting N (the "modulus") until the
result is within this range.
The original mathematical usage considers only __equivalence__
modulo N. The numbers being compared can take any values,
what matters is whether they differ by a multiple of N.
Computing usage however, considers modulo to be an operator
that returns the remainder after integer division of its first
argument by its second.
Ordinary "clock arithmetic" is like modular arithmetic except
that the range is [1..12] whereas modulo 12 would be [0..11].
(2003-03-28)
|
modulo operator
(foldoc) | modulo operator
(mod) The operator that returns the remainder
after integer division of its first argument by its second.
Written as "%" in C and some other languages.
Where the second argument is a power of two, the result can be
calculated much more quickly using bitwise and with the
appropriate bit-mask.
(1999-07-12)
|
tail recursion modulo cons
(foldoc) | tail recursion modulo cons
A generalisation of tail recursion
introduced by D.H.D. Warren. It applies when the last thing a
function does is to apply a constructor functions (e.g. cons)
to an application of a non-primitive function. This is
transformed into a tail call to the function which is also
passed a pointer to where its result should be written. E.g.
f [] = []
f (x:xs) = 1 : f xs
is transformed into (pseudo C/Haskell):
f [] = []
f l = f' l allocate_cons
f' [] p = { *p = nil;
return *p
}
f' (x:xs) p = { cell = allocate_cons;
*p = cell;
cell.head = 1;
return f' xs &cell.tail
}
where allocate_cons returns the address of a new cons cell, *p
is the location pointed to by p and &c is the address of c.
[D.H.D. Warren, DAI Research Report 141, University of
Edinburgh 1980].
(1995-03-06)
|
|