"neg" - Codish Lexicon

neg — arithmetic negation. number: mul -1. integer: returns the two's complement, which means to not2 then add 1. distinct: not, not2, negative related: abs, negative mentioned: scalar, signed ✍

abs — absolute value. returns the positive reflection of negative integers, returning positive numbers as they were. a transitive function that maps integers into the natural number line. distinct: absolute is: stateless, idempotent related: neg python: abs(number) -> number Return the absolute value of the argument.† perl: [number]: absolute value function† php: absolute value &dagger. distinct: pos related: positive ✍

negative — a unary boolean function that returns whether a value is lt zero. opposite: positive related: neg distinct: neg is: sign mentioned: abs, false, integer, signed, uint ✍

not — logical negation. related: not2 distinct: neg mentioned: nand, nand2, nor, nor2, nxor, nxor2, signed ✍

X not X

0 false true

1 true false

	`X`	`not X`
0	`false`	`true`
1	`true`	`false`

not2 — bitwise not. is: bitwise distinct: neg related: not ✍

mul — multiply. oppostie: div is: multiplicative, stateless related: unit related: and, product aka: array product opposite: div mentioned: complexity function, identity, linear logarithmic time, linear time, neg, non polynomial time, reciprocal ✍

add — returns the result of adding values arithmetically. opposite: sub is: arithmetic, stateless related: zero python: set: Add an element to a set. This has no effect if the element is already present.† related: bale, or, sum aka: concat, merge, plus distinct: extend mentioned: complexity function, end, identity, magnitude, neg, non polynomial time, signed ✍

scalar — pertains to 1-dimensional, non-negative values. related: linear, planar, spatial, temporal perl: force a scalar context† aka: planar mentioned: hash, lapse, vector ✍

signed — pertains: integers that use their big bit to represent whether the int is positive or negative. negative integers are usually stored in "two's complement" form, meaning that, neg can be calculated with not and adding 1. opposite: unsigned is: int related: sign mentioned: int16, int32, int64 ✍

identity: neg(x) eq (not(x) add 1)

positive — a unary boolean function that returns whether a value is ge zero. opposite: negative related: abs distinct: pos is: sign mentioned: cardinality, integer, natural, signed, true, uint, whole ✍

stateless — an attribute of a function that connotes that a function will always return the same result for given input. opposite: stateful classes: abs, absolute, add, div, first, mul, pad, reversed, slice, sub mentioned: expression, getset, transitive ✍

idempotent — (1.) of unary functions, converging on a return value when reapplied, as when the returned value of one application is passed back as a parameter. a unary function, f, is idempotent iff f(x) eq f(f(x)). (1.a.) an attribute of a unary function that denotes whether the function is idempotent for all values in its domain. (2.) of binary functions, returning the same value when that value is passed to both parameters. a value is idempotent for a binary function iff f(x, x) eq x. a binary function, g, is idempotent iff f(x, x) eq x for all x in its domain. (2.a.) a binary function that returns whether a particular value is idempotent for a given binary function, meaning f(x, x) eq x. (2.b.) an attribute of a binary function that denotes whether the function is idempotent for all values in the domain of both parameters. classes: abs, absolute, normal related: stateful ✍

absolute — returns the fully qualified path for a given path and the cwd. is: stateless, idempotent distinct: abs, normal, canonical ✍

pos — temporal: position. distinct: positive, abs, index, key perl: [regex]: find or set the offset for the last/next m//g search† php: alias of current() &dagger. see: index aka: position mentioned: remove, shift, time, unshift ✍

integer — pertains to number values that are positive, negative, and zero, but have no mantissa. integers have arbitrary magnitude. distinct: int distinct: natural, whole mentioned: abs, bitwise, genericity, pointer, rational, real, ref ✍

transitive function — concept: a unary function that consistently returns the corresponding value in a range for a given key in a domain. distinct: relation, binary relation, transitive relation ✍

map — a function that returns the respective values for an linear collection of keys and a transitive function. commute: each python: map(function, sequence[, sequence, ...]) -> list Return a list of the results of applying the function to the items of the argument sequence(s). If more than one sequence is given, the function is called with an argument list consisting of the corresponding item of each sequence, substituting None for missing values when not all sequences have the same length. If the function is None, return a list of the items of the sequence (or a list of tuples if more than one sequence).† perl: [list]: apply a change to a list to get back a new list with the changes† aka: array map pertains: iterable related: pair mentioned: abs, binary relation, enumerate, equivalence relation, font, zip with ✍

natural — pertains to number values that are positive or zero. natural numbers have arbitrary magnitude. distinct: integer, whole, uint mentioned: abs, binary, digit, unsigned ✍

number — concept: a whole, natural, integer, real, or complex numeric value. a transitive function that returns the corresponding number, usually limited to a subset of the real domain like int or float. ✍

sign — related: signed classes: positive, negative ✍

unary — describes functions that take one parameter. related: unit mentioned: boolean function, negative, positive, transitive function, transitive, unary function ✍

boolean function — a unary function that returns whether a value passes or fails a particular criterion or condition. is: function distinct: binary function distinct: binary relation mentioned: empty, filter, negative, positive ✍

value — data of any class. see: def, variable aka: datum related: dict ✍

lt — less than. is: transitive relation, binary relation inverse: ge related: min aka: smaller mentioned: le, less, negative ✍

zero — returns the arithmetic identity of a class, object, or group. this is a value that when added to any value of a particular class returns the same value. for numbers, this is the value of zero (0). for any collection class, this is an empty collection. for a string, this is a null string, "". for a tuple, this is the nuple. related: unit related: add, false, sub ✍

identity: x add x.class.zero = x

false — a boolean value that corresponds to all things negative or related: zero aka: no python: bool(x) -> bool Returns True when the argument x is true, False otherwise. The builtins True and False are the only two instances of the class bool. The class bool is a subclass of the class int, and cannot be subclassed.† mentioned: bit, cond, falsy ✍

uint — a magnitude-limited natural number. an unsigned int, meaning the most significant bit, the big end, does not represent whether the int is positive or negative, but rather adds another bit of precision. distinct: natural, whole ✍

logical — pertains to functions that operate on boolean values. includes: not, and, or, xor, nand, nor, nxor, cond, ncond distinct: binary, bitwise, boolean is: math classes: cond, ncond aka: logic ✍

nand — logical not and. opposite: and, nor ✍

Truth Tables
0 1 2 3 function

X false false true true

Y false true false true

0 false false false false false

1 false false false true X and Y

2 false false true false X ncond Y

3 false false true true X

4 false true false false Y ncond X

5 false true false true Y

6 false true true false X xor Y

7 false true true true X or Y

8 true false false false X nor Y

9 true false false true X nxor Y

10 true false true false not Y

11 true false true true Y cond X

12 true true false false not X

13 true true false true X cond Y

14 true true true false X nand Y

15 true true true true true

Truth Table
X Y X nand Y

0 false false true

1 false true true

2 true false true

3 true true false

Truth Tables
	0	1	2	3	function
`X`	`false`	`false`	`true`	`true`
`Y`	`false`	`true`	`false`	`true`
0	`false`	`false`	`false`	`false`	`false`
1	`false`	`false`	`false`	`true`	`X and Y`
2	`false`	`false`	`true`	`false`	`X ncond Y`
3	`false`	`false`	`true`	`true`	`X`
4	`false`	`true`	`false`	`false`	`Y ncond X`
5	`false`	`true`	`false`	`true`	`Y`
6	`false`	`true`	`true`	`false`	`X xor Y`
7	`false`	`true`	`true`	`true`	`X or Y`
8	`true`	`false`	`false`	`false`	`X nor Y`
9	`true`	`false`	`false`	`true`	`X nxor Y`
10	`true`	`false`	`true`	`false`	`not Y`
11	`true`	`false`	`true`	`true`	`Y cond X`
12	`true`	`true`	`false`	`false`	`not X`
13	`true`	`true`	`false`	`true`	`X cond Y`
14	`true`	`true`	`true`	`false`	`X nand Y`
15	`true`	`true`	`true`	`true`	`true`

Truth Table
	`X`	`Y`	`X nand Y`
0	`false`	`false`	`true`
1	`false`	`true`	`true`
2	`true`	`false`	`true`
3	`true`	`true`	`false`

nand2 — bitwise not and. is: bitwise ✍

nor — logical not or. opposite: or, nand ✍

Truth Table
X Y X nor Y

0 false false true

1 false true false

2 true false false

3 true true false

Truth Table
	`X`	`Y`	`X nor Y`
0	`false`	`false`	`true`
1	`false`	`true`	`false`
2	`true`	`false`	`false`
3	`true`	`true`	`false`

nor2 — bitwise not or. is: bitwise ✍

nxor — logical exclusive not or. see: eq is equivalent for the domain of booleans. related: nxor2 opposite: xor ✍

Truth Table
X Y X nxor Y

0 false false true

1 false true false

2 true false false

3 true true true

Truth Table
	`X`	`Y`	`X nxor Y`
0	`false`	`false`	`true`
1	`false`	`true`	`false`
2	`true`	`false`	`false`
3	`true`	`true`	`true`

nxor2 — bitwise not xor. is: bitwise related: nxor ✍

bitwise — pertains to functions that operate on integer values as an ordered linear collection of boolean bits. bitwise functions all conceptually apply the corresponding logical function on the respective bits includes: and2, or2, nand2, nor2, xor2, nxor2, not2 distinct: binary, boolean, logical classes: and2, nand2, nor2, not2, nxor2, or2, xor2 ✍

div — divide. opposite: mul is: multiplicative, stateless related: reciprocal, unit mentioned: atan, identity, radix64 ✍

and — logical conjunction. related: and2, intersect, mul opposite: or, nand related: or mentioned: nand2 ✍

Truth Table
X Y X and Y

0 false false false

1 false true false

2 true false false

3 true true true

Truth Table
	`X`	`Y`	`X and Y`
0	`false`	`false`	`false`
1	`false`	`true`	`false`
2	`true`	`false`	`false`
3	`true`	`true`	`true`

unit — returns the multiplicative identity of a class, object, or group. this is a value that when multiplied by any value of a particular class, returns the same value. for numbers, strings, and most other values, this is the value of one (1). for a matrix, this is a square matrix with unit 1's along the diagonal and zero 0's elsewhere. related: zero, unary related: div, mul mentioned: dec, inc, product ✍

identity: x mul x.class.unit = x

product — reduces an iterable collection of numbers to the product of all the values with mul and unit as a basis. values are not necessarily numbers. related: mul, sum ✍

multiplicative — includes: mul, div, mod, rem, unit is: arithmetic classes: div, mul, rem mentioned: math ✍

array product — see: mul php: calculate the product of values in an array &dagger. ✍

complexity function — a relation pertaining to collection algorithms that has the character of the relation from the number of values a collection has to the amount of time the algorithm will run. complexity relations are normalized for quick comparison of the character of algorithms as the size of their collection increases by reducing all additive constants and multiplicative factors to 1, and omitting logarithmic bases since all logarimic bases create curves that vary only by a multiplicative factor. mentioned: constant time, cube time, exponential time, linear logarithmic time, linear time, logarithmic time, non polynomial time, square time ✍

identity — a value for the second param of a binary function that causes the function to always return its first parameter. examples: unit for mul and div, zero for add and sub. distinct: id, is, ref ✍

linear logarithmic time — a complexity function with the character of {y = x mul (log x}. ✍

linear time — a complexity function with the character of {y = x mul a}, where {a} is a constant. ✍

non polynomial time — a complexity function that cannot be expressed with an algebraic function composed only of addition, multiplication, constant base logarithm, and constant base exponentiation. ✍

reciprocal — returns the multiplicative inverse for a value. related: div ✍

sub — calculates a difference of the latter from the former. opposite: add commute: diff distinct: subscript is: arithmetic, stateless related: zero perl: [control flow]: declare a subroutine, possibly anonymously; see: [function]† mentioned: identity ✍

bale — transforms an iterable into a list of accumulated sub-lists of a given length. related: zip, add aka: xargs pertains: iterable ✍

baled([1, 2, 3, 4]) eq [[1, 2], [3, 4]]

baled([1, 2, 3, 4, 5, 6], 3) eq [[1, 2, 3], [4, 5, 6]]

baled([1, 2, 3, 4, 5], 3) eq [[1, 2, 3], [4, 5]]

baled([1, 2, 3, 4, 5], 3, 0) eq [[1, 2, 3], [4, 5, 0]]

shell idiom: input | xargs -n 2

or — logical disjunction. related: and, or2, union, add opposite: and, nor mentioned: le, nor2, nxor, xor ✍

Truth Table
X Y X or Y

0 false false false

1 false true true

2 true false true

3 true true true