cstr int nat nat32 nat16 nat8 float bool err blank char any eq neq not Number is_different neg add mul div mod lt gt le ge sub pow console unsafe_console flush nn print supports_ansi colors set exists bits lshift rshift xor band bor of range next get KB MB GB alloc resize last mutlast mutget len new arena allocated status circular list at char_allocator strdat str copy copy_null_terminated unsafe_temp endpos slice starts_with ends_with contains is_number rotl splitmix64 Rand Hashable hash to_hash_base robinhood_str_entry robinhood_nat_entry robinhood_entry raw is_zero find strmap natmap unpack abs sqrt sin cos log tan floor asin acos atan exp isnan isinf vec mat sparse_element coo float_allocator constvec reduce dot sum mean var std self rows cols constmat mutvec row nnz todense matrix realloc free zero
Defined by the compiler
cstr() -> (cstr)
Defined in: std/core/string.s line 174
This function’s return is meant to be passed to operating system calls, or to comptime returns with the pattern ‘cstr unsafetemp stringvalue’.
cstr(cstr cstr, str) -> (cstr)
Defined in: std/core/string.s line 174
This function’s return is meant to be passed to operating system calls, or to comptime returns with the pattern ‘cstr unsafetemp stringvalue’.
cstr(unsafe_temp) -> (cstr)
Defined in: std/core/error.s line 19
Error codes should not be compared numerically against given numbers, as their numbering changes for different programs. Instead, they should be converted to a cstr string with this function, which can then be compared. This comparison is also one numerical comparison, as care is taken for all cstr to point to the same memory location.
cstr(catch) -> (cstr)
Defined by the compiler
Represents values in the range 2^-63 to 2^63-1.
int() -> (int)
Defined in: std/core/convert.s line 89
Converts a bit representation to the corresponding integer.
int(bits) -> (int)
Defined in: std/core/convert.s line 29
Overflows are mapped to negative integers and are not protected against.
int(nat) -> (int)
Defined in: std/core/convert.s line 29
Serves as a tautology function for code that parses on multiple number types.
int(int) -> (int)
Defined in: std/core/convert.s line 29
May lose information due to truncating.
int(float) -> (int)
Defined in: std/core/convertstr.s line 35
int(console) -> (int)
Potential errors:
Defined in: std/core/convertstr.s line 147
int(str) -> (int)
Potential errors:
Defined in: std/core/convertstr.s line 147
int(cstr) -> (int)
Potential errors:
Defined by the compiler
Represents values in the range 0 to 2^64-1.
nat() -> (nat)
Defined in: std/core/convert.s line 84
Converts a bit representation to the corresponding natural number.
nat(bits) -> (nat)
Defined in: std/core/convert.s line 51
Converting a character to a natural number considers its bit representation interpreted as an unsigned number.
nat(char) -> (nat)
Defined in: std/core/convert.s line 40
Converting to natural numbers loses information. Failed on negative input because it typically indicates a later error in buffer indexing.
nat(nat) -> (nat)
Defined in: std/core/convert.s line 40
Converting to natural numbers loses information. Failed on negative input because it typically indicates a later error in buffer indexing.
nat(int) -> (nat)
Potential errors:
Defined in: std/core/convert.s line 40
Converting to natural numbers loses information. Failed on negative input because it typically indicates a later error in buffer indexing.
nat(float) -> (nat)
Potential errors:
Defined in: std/core/array.s line 24
nat(nat16) -> (nat)
Defined in: std/core/convertstr.s line 59
nat(console) -> (nat)
Potential errors:
Defined in: std/core/convertstr.s line 170
nat(str) -> (nat)
Potential errors:
Defined in: std/core/convertstr.s line 170
nat(cstr) -> (nat)
Potential errors:
Defined in: std/mini.s line 30
nat(nat32) -> (nat)
Defined by the compiler
Represents values in the range 0 to 2^32-1.
nat32() -> (nat32)
Defined in: std/mini.s line 22
The conversion checks whether the previous value fits in the new one. If it does not, this operation can fail.
nat32(nat) -> (nat32)
Potential errors:
Defined by the compiler
Represents values in the range 0 to 2^16-1.
nat16() -> (nat16)
Defined in: std/mini.s line 14
The conversion checks whether the previous value fits in the new one. If it does not, this operation can fail.
nat16(nat) -> (nat16)
Potential errors:
Defined by the compiler
Represents values in the range 0 to 255.
nat8() -> (nat8)
Defined in: std/mini.s line 6
The conversion checks whether the previous value fits in the new one. If it does not, this operation can fail.
nat8(nat) -> (nat8)
Potential errors:
Defined by the compiler
float() -> (float)
Defined in: std/core/convert.s line 95
Converts a bit representation to the corresponding float number.
float(bits) -> (float)
Defined in: std/core/convert.s line 20
May lose information because floats are not exact representation of all integers.
float(nat) -> (float)
Defined in: std/core/convert.s line 20
May lose information because floats are not exact representation of all integers.
float(int) -> (float)
Defined in: std/core/convert.s line 20
Serves as a tautology function for code that parses on multiple number types.
float(float) -> (float)
Defined in: std/core/convertstr.s line 79
float(console) -> (float)
Potential errors:
Defined in: std/core/convertstr.s line 183
float(str) -> (float)
Potential errors:
Defined in: std/core/convertstr.s line 183
float(cstr) -> (float)
Potential errors:
Defined by the compiler
Can only be true or false.
bool() -> (bool)
Defined by the compiler
err() -> (err)
Defined by the compiler
This is the type of non-existent variables, empty parantheses, and functions of no returns.
void() -> ()
Defined by the compiler
Represents characters in the numeric range 0 to 255.
char() -> (char)
Defined in: std/core/string.s line 112
The first character of a string is extracted,
for example to write c = char \"C\".
char(cstr) -> (char)
Defined in: std/core/string.s line 106
The first character of a string is extracted,
for example to write c = char str \"C\".
char(str) -> (char)
Defined in: std/core/convertstr.s line 23
char(console) -> (char)
Potential errors:
Defined by the compiler
Represents a generic for buffers and pointers for type-independent code that can be matched to a concrete type later.
any() -> ()
Defined in: std/core/numbers.s line 56
Compares the address of two pointers.
eq(any ptr x, any ptr y) -> (bool)
Defined in: std/core/numbers.s line 40
Compares two error messages. This comparison is used only for comparing error messages produced by the same running program.
eq(catch x, catch y) -> (bool)
Defined in: std/core/numbers.s line 26
eq(nat x, nat y) -> (bool)
Defined in: std/core/numbers.s line 26
eq(int x, int y) -> (bool)
Defined in: std/core/numbers.s line 26
eq(float x, float y) -> (bool)
Defined in: std/core/bool.s line 82
eq(bool value, false) -> (bool)
Defined in: std/core/bool.s line 78
eq(false, bool value) -> (bool)
Defined in: std/core/bool.s line 74
eq(bool value, true) -> (bool)
Defined in: std/core/bool.s line 70
eq(true, bool value) -> (bool)
Defined in: std/core/bool.s line 51
This is a compile-time operations that does not evoke any runtime booleans.
eq(false, true) -> (false)
Defined in: std/core/bool.s line 46
This is a compile-time operations that does not evoke any runtime booleans.
eq(true, false) -> (false)
Defined in: std/core/bool.s line 41
This is a compile-time operations that does not evoke any runtime booleans.
eq(false, false) -> (true)
Defined in: std/core/bool.s line 36
This is a compile-time operations that does not evoke any runtime booleans.
eq(true, true) -> (true)
Defined in: std/core/bool.s line 20
eq(bool x, bool y) -> (bool)
Defined in: std/core/string.s line 207
eq(cstr x, str) -> (bool)
Potential errors:
Defined in: std/core/string.s line 201
eq(str, cstr y) -> (bool)
Potential errors:
Defined in: std/core/string.s line 191
eq(str, str) -> (bool)
Defined in: std/core/string.s line 186
eq(cstr x, cstr y) -> (bool)
Defined in: std/core/string.s line 119
eq(char x, char y) -> (bool)
Defined in: std/core/numbers.s line 62
Compares the address of two pointers.
neq(any ptr x, any ptr y) -> (bool)
Defined in: std/core/numbers.s line 48
Compares two error messages. This comparison is used only for comparing error messages produced by the same running program.
neq(catch x, catch y) -> (bool)
Defined in: std/core/numbers.s line 33
neq(nat x, nat y) -> (bool)
Defined in: std/core/numbers.s line 33
neq(int x, int y) -> (bool)
Defined in: std/core/numbers.s line 33
neq(float x, float y) -> (bool)
Defined in: std/core/bool.s line 90
neq(bool x, false y) -> (bool)
Defined in: std/core/bool.s line 90
neq(bool x, true y) -> (bool)
Defined in: std/core/bool.s line 86
neq(false x, bool y) -> (bool)
Defined in: std/core/bool.s line 86
neq(true x, bool y) -> (bool)
Defined in: std/core/bool.s line 66
neq(false x, false y) -> (false)
Defined in: std/core/bool.s line 66
neq(false x, true y) -> (true)
Defined in: std/core/bool.s line 66
neq(true x, false y) -> (true)
Defined in: std/core/bool.s line 66
neq(true x, true y) -> (false)
Defined in: std/core/bool.s line 25
neq(bool x, bool y) -> (bool)
Defined in: std/core/string.s line 213
neq(str, str) -> (bool)
Defined in: std/core/string.s line 124
neq(char x, char y) -> (bool)
Defined in: std/core/string.s line 213
neq(cstr x, cstr y) -> (bool)
Defined in: std/core/string.s line 213
neq(cstr x, str) -> (bool)
Potential errors:
Defined in: std/core/string.s line 213
neq(str, cstr y) -> (bool)
Potential errors:
Defined in: std/core/bool.s line 61
This is a compile-time operations on the compiler::false type rather than a runtime boolean.
not(false) -> (true)
Defined in: std/core/bool.s line 56
This is a compile-time operations on the compiler::true type rather than a runtime boolean.
not(true) -> (false)
Defined in: std/core/bool.s line 30
This operates on boolean values at runtime.
not(bool) -> (bool)
Defined by the compiler
Represents values in the range 0 to 2^64-1.
nat() -> (nat)
Defined by the compiler
float() -> (float)
Defined by the compiler
Represents values in the range 2^-63 to 2^63-1.
int() -> (int)
Defined in: std/core/numbers.s line 23
is_different(nat x, nat y) -> (false)
Defined in: std/core/numbers.s line 23
is_different(nat x, int y) -> (true)
Defined in: std/core/numbers.s line 23
is_different(nat x, float y) -> (true)
Defined in: std/core/numbers.s line 23
is_different(int x, nat y) -> (true)
Defined in: std/core/numbers.s line 23
is_different(int x, int y) -> (false)
Defined in: std/core/numbers.s line 23
is_different(int x, float y) -> (true)
Defined in: std/core/numbers.s line 23
is_different(float x, nat y) -> (true)
Defined in: std/core/numbers.s line 23
is_different(float x, int y) -> (true)
Defined in: std/core/numbers.s line 23
is_different(float x, float y) -> (false)
Defined in: std/core/numbers.s line 68
neg(nat) -> (nat)
Defined in: std/core/numbers.s line 68
neg(int) -> (int)
Defined in: std/core/numbers.s line 68
neg(float) -> (float)
Defined in: std/core/numbers.s line 73
Adds two numbers of the same type. This is an overload for the + operator.
add(nat x, nat y) -> (nat)
Defined in: std/core/numbers.s line 73
Adds two numbers of the same type. This is an overload for the + operator.
add(int x, int y) -> (int)
Defined in: std/core/numbers.s line 73
Adds two numbers of the same type. This is an overload for the + operator.
add(float x, float y) -> (float)
Defined in: std/unsafe.s line 54
Adds a natural number offset to a pointer.
add(any ptr allocated, nat offset) -> (any ptr {follows any ptr allocated})
Defined in: std/core/string.s line 302
add(edit list, cstr _s1, cstr _s2) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 302
add(edit list, cstr _s1, str) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 302
add(edit list, str, cstr _s2) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 302
add(edit list, str, str) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 302
add(edit circular, cstr _s1, cstr _s2) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 302
add(edit circular, cstr _s1, str) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 302
add(edit circular, str, cstr _s2) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 302
add(edit circular, str, str) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 302
add(edit arena, cstr _s1, cstr _s2) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 302
add(edit arena, cstr _s1, str) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 302
add(edit arena, str, cstr _s2) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 302
add(edit arena, str, str) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 302
add(new CHARS, cstr _s1, cstr _s2) -> (str) with effects CHARS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/string.s line 302
add(new CHARS, cstr _s1, str) -> (str) with effects CHARS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/string.s line 302
add(new CHARS, str, cstr _s2) -> (str) with effects CHARS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/string.s line 302
add(new CHARS, str, str) -> (str) with effects CHARS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/vec.s line 60
Grabs an FLOATS for the result as an effect.
add(new FLOATS, vec, float v2) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/vec.s line 60
Grabs an FLOATS for the result as an effect.
add(edit arena, vec, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 71
Grabs an FLOATS for the result as an effect.
add(edit circular, float v1, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 71
Grabs an FLOATS for the result as an effect.
add(edit arena, float v1, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 71
Grabs an FLOATS for the result as an effect.
add(new FLOATS, float v1, vec) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/vec.s line 60
Grabs an FLOATS for the result as an effect.
add(edit circular, vec, float v2) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 60
Grabs an FLOATS for the result as an effect.
add(edit circular, vec, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 60
Grabs an FLOATS for the result as an effect.
add(edit arena, vec, float v2) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 60
Grabs an FLOATS for the result as an effect.
add(new FLOATS, vec, vec) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/numbers.s line 81
Multiplies two numbers of the same type. This is an overload for the * operator.
mul(nat x, nat y) -> (nat)
Defined in: std/core/numbers.s line 81
Multiplies two numbers of the same type. This is an overload for the * operator.
mul(int x, int y) -> (int)
Defined in: std/core/numbers.s line 81
Multiplies two numbers of the same type. This is an overload for the * operator.
mul(float x, float y) -> (float)
Defined in: std/sci/vec.s line 106
Grabs an FLOATS for the result as an effect.
mul(edit circular, float v1, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 106
Grabs an FLOATS for the result as an effect.
mul(edit arena, float v1, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 106
Grabs an FLOATS for the result as an effect.
mul(new FLOATS, float v1, vec) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/vec.s line 95
Grabs an FLOATS for the result as an effect.
mul(edit circular, vec, float v2) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 95
Grabs an FLOATS for the result as an effect.
mul(edit circular, vec, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 95
Grabs an FLOATS for the result as an effect.
mul(edit arena, vec, float v2) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 95
Grabs an FLOATS for the result as an effect.
mul(edit arena, vec, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 95
Grabs an FLOATS for the result as an effect.
mul(new FLOATS, vec, float v2) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/vec.s line 95
Grabs an FLOATS for the result as an effect.
mul(new FLOATS, vec, vec) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/mat.s line 102
Grabs an allocator for the result as an effect.
mul(edit arena, mat, mat) -> (mut mat) with effects FLOATS
Potential errors:
Defined in: std/sci/mat.s line 102
Grabs an allocator for the result as an effect.
mul(new FLOATS, mat, mat) -> (mut mat) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/mat.s line 90
Grabs an allocator for the result as an effect.
mul(edit circular, vec, mat) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/mat.s line 90
Grabs an allocator for the result as an effect.
mul(edit arena, vec, mat) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/mat.s line 90
Grabs an allocator for the result as an effect.
mul(new FLOATS, vec, mat) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/mat.s line 78
Grabs an allocator for the result as an effect.
mul(edit circular, mat, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/mat.s line 78
Grabs an allocator for the result as an effect.
mul(edit arena, mat, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/mat.s line 78
Grabs an allocator for the result as an effect.
mul(new FLOATS, mat, vec) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/coo.s line 71
mul(edit circular, coo, mat) -> (mut mat) with effects FLOATS
Potential errors:
Defined in: std/sci/coo.s line 71
mul(edit arena, coo, mat) -> (mut mat) with effects FLOATS
Potential errors:
Defined in: std/sci/coo.s line 71
mul(new FLOATS, coo, mat) -> (mut mat) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/coo.s line 61
*Warning: the expression self(v)*m yields wrong values
mul(edit circular, vec, coo) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/coo.s line 61
*Warning: the expression self(v)*m yields wrong values
mul(edit arena, vec, coo) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/coo.s line 61
*Warning: the expression self(v)*m yields wrong values
mul(new FLOATS, vec, coo) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/coo.s line 53
mul(edit circular, coo, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/coo.s line 53
mul(edit arena, coo, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/coo.s line 53
mul(new FLOATS, coo, vec) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/mat.s line 102
Grabs an allocator for the result as an effect.
mul(edit circular, mat, mat) -> (mut mat) with effects FLOATS
Potential errors:
Defined in: std/core/numbers.s line 89
Divides two numbers of the same type. This is an overload for the / operator. Safeguards against division by zero.
div(float x, float y) -> (float)
Potential errors:
Defined in: std/core/numbers.s line 89
Divides two numbers of the same type. This is an overload for the / operator. Safeguards against division by zero.
div(int x, int y) -> (int)
Potential errors:
Defined in: std/core/numbers.s line 89
Divides two numbers of the same type. This is an overload for the / operator. Safeguards against division by zero.
div(nat x, nat y) -> (nat)
Potential errors:
Defined in: std/sci/vec.s line 143
Grabs an FLOATS for the result as an effect.
div(edit circular, float v1, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 143
Grabs an FLOATS for the result as an effect.
div(edit arena, float v1, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 143
Grabs an FLOATS for the result as an effect.
div(new FLOATS, float v1, vec) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/vec.s line 131
Grabs an FLOATS for the result as an effect.
div(edit circular, vec, float v2) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 131
Grabs an FLOATS for the result as an effect.
div(edit circular, vec, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 131
Grabs an FLOATS for the result as an effect.
div(edit arena, vec, float v2) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 131
Grabs an FLOATS for the result as an effect.
div(edit arena, vec, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 131
Grabs an FLOATS for the result as an effect.
div(new FLOATS, vec, float v2) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/vec.s line 131
Grabs an FLOATS for the result as an effect.
div(new FLOATS, vec, vec) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/numbers.s line 101
Computes the modulo between two natural numbers. This is an overload for the % operator.
mod(nat x, nat y) -> (nat)
Potential errors:
Defined in: std/core/numbers.s line 110
Compares two numbers of the same type. This is an overload for the < operator.
lt(nat x, nat y) -> (bool)
Defined in: std/core/numbers.s line 110
Compares two numbers of the same type. This is an overload for the < operator.
lt(float x, float y) -> (bool)
Defined in: std/core/numbers.s line 110
Compares two numbers of the same type. This is an overload for the < operator.
lt(int x, int y) -> (bool)
Defined in: std/core/numbers.s line 118
greater than
gt(float x, float y) -> (bool)
Defined in: std/core/numbers.s line 118
greater than
gt(int x, int y) -> (bool)
Defined in: std/core/numbers.s line 118
greater than
gt(nat x, nat y) -> (bool)
Defined in: std/core/numbers.s line 126
Compares two numbers of the same type. This is an overload for the <= operator.
le(nat x, nat y) -> (bool)
Defined in: std/core/numbers.s line 126
Compares two numbers of the same type. This is an overload for the <= operator.
le(float x, float y) -> (bool)
Defined in: std/core/numbers.s line 126
Compares two numbers of the same type. This is an overload for the <= operator.
le(int x, int y) -> (bool)
Defined in: std/core/numbers.s line 134
Compares two numbers of the same type. This is an overload for the >= operator.
ge(nat x, nat y) -> (bool)
Defined in: std/core/numbers.s line 134
Compares two numbers of the same type. This is an overload for the >= operator.
ge(int x, int y) -> (bool)
Defined in: std/core/numbers.s line 134
Compares two numbers of the same type. This is an overload for the >= operator.
ge(float x, float y) -> (bool)
Defined in: std/core/numbers.s line 142
Subtracts two numbers of the same type. This is an overload for the - operator. Natural numbers are safeguarded against acquiring negative results, which would overflow.
sub(nat x, nat y) -> (nat)
Potential errors:
Defined in: std/core/numbers.s line 142
Subtracts two numbers of the same type. This is an overload for the - operator.
sub(int x, int y) -> (int)
Defined in: std/core/numbers.s line 142
Subtracts two numbers of the same type. This is an overload for the - operator.
sub(float x, float y) -> (float)
Defined in: std/sci/vec.s line 87
Grabs an FLOATS for the result as an effect.
sub(edit circular, float v1, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 87
Grabs an FLOATS for the result as an effect.
sub(edit arena, float v1, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 87
Grabs an FLOATS for the result as an effect.
sub(new FLOATS, float v1, vec) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/vec.s line 76
Grabs an FLOATS for the result as an effect.
sub(edit circular, vec, float v2) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 76
Grabs an FLOATS for the result as an effect.
sub(edit circular, vec, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 76
Grabs an FLOATS for the result as an effect.
sub(edit arena, vec, float v2) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 76
Grabs an FLOATS for the result as an effect.
sub(edit arena, vec, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 76
Grabs an FLOATS for the result as an effect.
sub(new FLOATS, vec, float v2) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/vec.s line 76
Grabs an FLOATS for the result as an effect.
sub(new FLOATS, vec, vec) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/numbers.s line 154
Exponentiates a natural number by another.
pow(nat x, nat y) -> (mut nat)
Defined in: std/sci/math.s line 58
pow(float x, float y) -> (float)
Defined in: std/sci/vec.s line 123
Grabs an FLOATS for the result as an effect.
pow(edit circular, float v1, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 123
Grabs an FLOATS for the result as an effect.
pow(edit arena, float v1, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 123
Grabs an FLOATS for the result as an effect.
pow(new FLOATS, float v1, vec) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/vec.s line 112
Grabs an FLOATS for the result as an effect.
pow(edit circular, vec, float v2) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 112
Grabs an FLOATS for the result as an effect.
pow(edit circular, vec, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 112
Grabs an FLOATS for the result as an effect.
pow(edit arena, vec, float v2) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 112
Grabs an FLOATS for the result as an effect.
pow(edit arena, vec, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 112
Grabs an FLOATS for the result as an effect.
pow(new FLOATS, vec, float v2) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/vec.s line 112
Grabs an FLOATS for the result as an effect.
pow(new FLOATS, vec, vec) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/print.s line 20
As a singleton, the console should usually be instantiated
in the main() function and then passed to dependent calls, for example via an
an effect for convenience. Standard library print functions provide the CLI effect
and you can propagate to this by prepending effect edit console CLI to function
arguments.
The console is a zero-cost abstraction in that it does not transfer any data
but relies on singleton safety to synchronize io across threads.
Quickly print internals for debugging without with unsafe_console().
console() -> (console)
Defined in: std/core/print.s line 35
This is convenient for print debugging by writing unsafe_console().print ...
without needing to evoke an effect to pass the normally singleton console.
unsafe_console() -> (console)
Defined in: std/core/print.s line 43
flush(console) -> () with effects CLI
Defined in: std/core/print.s line 47
Given a value, creates a tuple of (value, ""). This enables the pattern ‘print nn value’ to print without automatically adding a new line.
nn(nat) -> (nat value, cstr)
Defined in: std/core/print.s line 47
Given a value, creates a tuple of (value, ""). This enables the pattern ‘print nn value’ to print without automatically adding a new line.
nn(int) -> (int value, cstr)
Defined in: std/core/print.s line 47
Given a value, creates a tuple of (value, ""). This enables the pattern ‘print nn value’ to print without automatically adding a new line.
nn(float) -> (float value, cstr)
Defined in: std/core/print.s line 47
Given a value, creates a tuple of (value, ""). This enables the pattern ‘print nn value’ to print without automatically adding a new line.
nn(cstr) -> (cstr value, cstr)
Defined in: std/core/string.s line 295
Given a value, creates a tuple of (value, ""). This enables the pattern ‘print nn value’ to print without a new line.
nn(str) -> (str, cstr)
Defined in: std/sci/vec.s line 214
Given a value, creates a tuple of (value, ""). This enables the pattern ‘print nn value’ to print without a new line.
nn(vec) -> (vec, cstr)
Defined in: std/core/print.s line 83
Automatically ends the line too.
print(console CLI, bool value) -> () with effects CLI
Defined in: std/core/print.s line 83
print(console CLI, bool value, cstr endl) -> () with effects CLI
Defined in: std/core/print.s line 76
Automatically ends the line too.
print(console CLI, nat value) -> () with effects CLI
Defined in: std/core/print.s line 76
print(console CLI, nat value, cstr endl) -> () with effects CLI
Defined in: std/core/print.s line 69
Automatically ends the line too.
print(console CLI, int value) -> () with effects CLI
Defined in: std/core/print.s line 69
print(console CLI, int value, cstr endl) -> () with effects CLI
Defined in: std/core/print.s line 61
To pre-specified 6 decimal digits. Automatically ends the line too.
print(console CLI, float value) -> () with effects CLI
Defined in: std/core/print.s line 61
To pre-specified 6 decimal digits.
print(console CLI, float value, cstr endl) -> () with effects CLI
Defined in: std/core/print.s line 54
Automatically ends the line too.
print(console CLI, cstr value) -> () with effects CLI
Defined in: std/core/print.s line 54
print(console CLI, cstr value, cstr endl) -> () with effects CLI
Defined in: std/core/print.s line 90
print(console CLI, true, cstr endl) -> () with effects CLI
Defined in: std/core/print.s line 90
Automatically ends the line too.
print(console CLI, true) -> () with effects CLI
Defined in: std/core/print.s line 97
print(console CLI, false, cstr endl) -> () with effects CLI
Defined in: std/core/print.s line 97
Automatically ends the line too.
print(console CLI, false) -> () with effects CLI
Defined in: std/core/string.s line 245
Ends the line too.
print(console CLI, char c) -> () with effects CLI
Defined in: std/core/string.s line 245
print(console CLI, char c, cstr endl) -> () with effects CLI
Defined in: std/core/string.s line 234
Ends the line too.
print(console CLI, str) -> () with effects CLI
Defined in: std/core/string.s line 234
print(console CLI, str, cstr endl) -> () with effects CLI
Defined in: std/io/file.s line 113
print(edit write, cstr text) -> ()
Potential errors:
Defined in: std/io/file.s line 113
print(edit write, cstr text) -> ()
Potential errors:
Defined in: std/io/file.s line 113
print(edit terminal, cstr text) -> ()
Potential errors:
Defined in: std/io/file.s line 107
print(edit write, str) -> ()
Potential errors:
Defined in: std/io/file.s line 107
print(edit terminal, str) -> ()
Potential errors:
Defined in: std/io/file.s line 107
print(edit write, str) -> ()
Potential errors:
Defined in: std/sci/vec.s line 221
Prints as a row, such as [ 1.0 2.0 3.0 ]
print(console CLI, vec) -> () with effects CLI
Potential errors:
Defined in: std/sci/vec.s line 221
Prints as a row, such as [ 1.0 2.0 3.0 ]
print(console CLI, vec, cstr endl) -> () with effects CLI
Potential errors:
Defined in: std/sci/coo.s line 87
Prints it as coordinate as list: (i, j): v
print(console CLI, coo) -> () with effects CLI
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/coo.s line 87
Prints it as coordinate as list: (i, j): v
print(console CLI, coo, cstr endl) -> () with effects CLI
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/mat.s line 116
single-row matrices stay on one line; taller ones get top/mid/bottom brackets
print(console CLI, mat) -> () with effects CLI
Potential errors:
Defined in: std/sci/mat.s line 116
single-row matrices stay on one line; taller ones get top/mid/bottom brackets
print(console CLI, mat, cstr endl) -> () with effects CLI
Potential errors:
Defined in: std/core/print.s line 104
supports_ansi(console) -> (bool)
[supports_ansi()]Defined in: std/core/print.s line 109
colors(console) -> (colors)
Returned values defer use of the following functions:
Defined in: std/core/print.s line 182
set(colors, "reset_underline") -> ()
Defined in: std/core/print.s line 180
set(colors, "reset_bold") -> ()
Defined in: std/core/print.s line 178
set(colors, "reset_bg") -> ()
Defined in: std/core/print.s line 176
set(colors, "reset_color") -> ()
Defined in: std/core/print.s line 174
set(colors, "reset") -> ()
Defined in: std/core/print.s line 172
set(colors, "strikethrough") -> ()
Defined in: std/core/print.s line 170
set(colors, "reverse") -> ()
Defined in: std/core/print.s line 168
set(colors, "blink") -> ()
Defined in: std/core/print.s line 166
set(colors, "underline") -> ()
Defined in: std/core/print.s line 164
set(colors, "italic") -> ()
Defined in: std/core/print.s line 162
set(colors, "dim") -> ()
Defined in: std/core/print.s line 160
set(colors, "bold") -> ()
Defined in: std/core/print.s line 158
set(colors, "bg_black") -> ()
Defined in: std/core/print.s line 156
set(colors, "bg_white") -> ()
Defined in: std/core/print.s line 154
set(colors, "bg_cyan") -> ()
Defined in: std/core/print.s line 152
set(colors, "bg_magenta") -> ()
Defined in: std/core/print.s line 150
set(colors, "bg_blue") -> ()
Defined in: std/core/print.s line 148
set(colors, "bg_yellow") -> ()
Defined in: std/core/print.s line 146
set(colors, "bg_green") -> ()
Defined in: std/core/print.s line 144
set(colors, "bg_red") -> ()
Defined in: std/core/print.s line 142
set(colors, "bright_white") -> ()
Defined in: std/core/print.s line 136
set(colors, "bright_blue") -> ()
Defined in: std/core/print.s line 138
set(colors, "bright_magenta") -> ()
Defined in: std/core/print.s line 140
set(colors, "bright_cyan") -> ()
Defined in: std/core/print.s line 126
set(colors, "white") -> ()
Defined in: std/core/print.s line 124
set(colors, "cyan") -> ()
Defined in: std/core/print.s line 122
set(colors, "magenta") -> ()
Defined in: std/core/print.s line 120
set(colors, "blue") -> ()
Defined in: std/core/print.s line 118
set(colors, "yellow") -> ()
Defined in: std/core/print.s line 116
set(colors, "green") -> ()
Defined in: std/core/print.s line 114
set(colors, "red") -> ()
Defined in: std/core/print.s line 134
set(colors, "bright_yellow") -> ()
Defined in: std/core/print.s line 132
set(colors, "bright_green") -> ()
Defined in: std/core/print.s line 130
set(colors, "bright_red") -> ()
Defined in: std/core/print.s line 128
set(colors, "black") -> ()
Defined in: std/core/convert.s line 58
exists(any ptr) -> (bool)
Defined in: std/core/string.s line 30
exists(cstr) -> (bool)
Defined in: std/core/convert.s line 76
Retrives the bit representation of a number of shift arithmetics and bitwise operations.
bits(float) -> (bits)
Defined in: std/core/convert.s line 69
Retrives the bit representation of a number of shift arithmetics and bitwise operations.
bits(int) -> (bits)
Defined in: std/core/convert.s line 63
Retrives the bit representation of a number of shift arithmetics and bitwise operations.
bits(nat) -> (bits)
Defined in: std/core/convert.s line 102
lshift(bits, nat y) -> (bits)
Defined in: std/core/convert.s line 107
rshift(bits, nat y) -> (bits)
Defined in: std/core/convert.s line 112
xor(bits, bits) -> (bits)
Defined in: std/core/convert.s line 117
band(bits, bits) -> (bits)
Defined in: std/core/convert.s line 122
bor(bits, bits) -> (bits)
Defined in: std/core/range.s line 24
Represents the range [from, to) where ‘from’ and ‘to’ are the arguments.
of(nat from, "to", nat to) -> (nat from, nat to)
Defined in: std/core/range.s line 19
Represents the range [0, to) where ‘to’ its its arguments.
of(nat) -> (nat, nat to)
Defined in: std/core/range.s line 34
Represents the range [from, from+length] where ‘from’ and ‘length’ are the arguments.
of(nat from, "len", nat length) -> (nat from, nat)
Defined in: std/core/range.s line 29
Represents the range [from, to] where ‘from’ and ‘to’ are the arguments.
of(nat from, "upto", nat to) -> (nat from, nat)
Defined in: std/core/range.s line 39
Endpoints are natural numbers (unsigned integers). This is handy for several kinds of iteration.
range(nat _from, nat to) -> (edit range)
Defined in: std/core/range.s line 45
This increments the r.from position and returns the previous one.
next(edit range) -> (nat)
Potential errors:
Defined in: std/map.s line 38
next(robinhood_nat_entry[], mut nat pos) -> (mut nat)
Potential errors:
Defined in: std/map.s line 38
next(robinhood_str_entry[], mut nat pos) -> (mut str)
Potential errors:
Defined in: std/rand.s line 88
next(mut Rand) -> (float)
Defined in: std/core/allocators.s line 52
get(list, nat pos) -> (any ptr {follows any ptr self.buf.unsafe_ptr})
Potential errors:
Defined in: std/core/allocators.s line 52
get(circular, nat pos) -> (any ptr {follows any ptr self.buf.unsafe_ptr})
Potential errors:
Defined in: std/core/array.s line 89
get(any[], nat i) -> (any ptr {follows any ptr buffer.unsafe_ptr})
Potential errors:
Defined in: std/core/range.s line 54
The item itself is returned. This lets the range be used as an iterator
per a pattern like for i in range 10 ....
get(range, nat pos) -> (nat)
Potential errors:
Defined in: std/core/string.s line 241
get(str, nat i) -> (char ptr)
Defined in: std/io.s line 10
get(edit circular, edit open, nat) -> (str) with effects CHARS
Potential errors:
Defined in: std/io.s line 10
get(edit arena, edit open, nat) -> (str) with effects CHARS
Potential errors:
Defined in: std/io.s line 10
get(edit arena, edit terminal, nat) -> (str) with effects CHARS
Potential errors:
Defined in: std/io.s line 10
get(edit arena, edit write, nat) -> (str) with effects CHARS
Potential errors:
Defined in: std/io/web.s line 15
This creates a GET request using the system’s curl. This implementation is ideal for obtaining individual files without additional dependencies. Retrieved data are saved to a specified file path, overwriting it. For ease of use, the path is returned. This version downloads to a ‘.tmp’ file.
get(console CLI, str) -> (str) with effects CLI
Potential errors:
Defined in: std/io/web.s line 15
This creates a GET request using the system’s curl. This implementation is ideal for obtaining individual files without additional dependencies. Retrieved data are saved to a specified file path, overwriting it. For ease of use, the path is returned.
get(console CLI, str, cstr path) -> (str) with effects CLI
Potential errors:
Defined in: std/io/web.s line 15
This creates a GET request using the system’s curl. This implementation is ideal for obtaining individual files without additional dependencies. Retrieved data are saved to a specified file path, overwriting it. For ease of use, the path is returned.
get(console CLI, str, str) -> (str) with effects CLI
Potential errors:
Defined in: std/io/web.s line 15
This creates a GET request using the system’s curl. This implementation is ideal for obtaining individual files without additional dependencies. Retrieved data are saved to a specified file path, overwriting it. For ease of use, the path is returned.
get(console CLI, cstr url, str) -> (str) with effects CLI
Potential errors:
Defined in: std/io.s line 10
get(edit arena, edit write, nat) -> (str) with effects CHARS
Potential errors:
Defined in: std/io.s line 10
get(edit arena, edit open, nat) -> (str) with effects CHARS
Potential errors:
Defined in: std/io.s line 10
get(edit arena, edit open, nat) -> (str) with effects CHARS
Potential errors:
Defined in: std/io.s line 7
get(edit open, nat) -> (str)
Potential errors:
Defined in: std/io/web.s line 15
This creates a GET request using the system’s curl. This implementation is ideal for obtaining individual files without additional dependencies. Retrieved data are saved to a specified file path, overwriting it. For ease of use, the path is returned. This version downloads to a ‘.tmp’ file.
get(console CLI, cstr url) -> (str) with effects CLI
Potential errors:
Defined in: std/io/web.s line 15
This creates a GET request using the system’s curl. This implementation is ideal for obtaining individual files without additional dependencies. Retrieved data are saved to a specified file path, overwriting it. For ease of use, the path is returned.
get(console CLI, cstr url, cstr path) -> (str) with effects CLI
Potential errors:
Defined in: std/map.s line 28
Implemented for string or cstr keys but buffer of any values.
get(robinhood_nat_entry[], any[], nat key) -> (any ptr {follows any ptr values.unsafe_ptr})
Potential errors:
Defined in: std/map.s line 18
Implemented for string or cstr keys but buffer of any values.
get(robinhood_str_entry[], any[], str) -> (any ptr {follows any ptr values.unsafe_ptr})
Potential errors:
Defined in: std/map.s line 18
Implemented for string or cstr keys but buffer of any values.
get(robinhood_str_entry[], any[], cstr key) -> (any ptr {follows any ptr values.unsafe_ptr})
Potential errors:
Defined in: std/io.s line 10
get(edit circular, edit open, nat) -> (str) with effects CHARS
Potential errors:
Defined in: std/io.s line 10
get(edit circular, edit terminal, nat) -> (str) with effects CHARS
Potential errors:
Defined in: std/io.s line 10
get(edit circular, edit write, nat) -> (str) with effects CHARS
Potential errors:
Defined in: std/io.s line 10
get(edit circular, edit write, nat) -> (str) with effects CHARS
Potential errors:
Defined in: std/io.s line 10
get(edit circular, edit open, nat) -> (str) with effects CHARS
Potential errors:
Defined in: std/sci/vec.s line 49
get(vec, nat i) -> (float ptr)
Potential errors:
Defined in: std/sci/mat.s line 49
get(mat, nat i, nat j) -> (float ptr)
Potential errors:
Defined in: std/sci/coo.s line 43
get(coo, nat k) -> (sparse_element ptr)
Potential errors:
Defined in: std/core/units.s line 19
KB(nat) -> (nat)
Defined in: std/core/units.s line 23
MB(nat) -> (nat)
Defined in: std/core/units.s line 27
GB(nat) -> (nat)
Defined in: std/core/string.s line 26
alloc(new CHARS, nat length) -> (edit allocated) with effects CHARS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/allocators.s line 85
Creates room for one element.
alloc(edit list) -> (edit allocated)
Potential errors:
Defined in: std/core/allocators.s line 85
alloc(edit list, nat length) -> (edit allocated)
Potential errors:
Defined in: std/core/allocators.s line 71
Creates room for one element.
alloc(edit circular) -> (edit allocated)
Potential errors:
Defined in: std/core/allocators.s line 71
alloc(edit circular, nat length) -> (edit allocated)
Potential errors:
Defined in: std/core/allocators.s line 60
Creates room for one element.
alloc(edit arena) -> (edit allocated)
Potential errors:
Defined in: std/core/allocators.s line 60
alloc(edit arena, nat length) -> (edit allocated)
Potential errors:
Defined in: std/core/array.s line 52
alloc(nat) -> (edit char[])
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/array.s line 28
Allocates an empty buffer and zero-initializes it. This is stable with regards to pointers,
as it never reallocates an allocation. For convenience for usage within loops, allocation
of the same size only zero-initializes the buffer. If a different size is given, and the
buffer is non-empty, this fails. Consider freeing the buffer first with del buffer to
allocate again, or use ‘buffer.resize new_size’ once a first non-zero allocation has been made.
This version allocates a buffer of ONE element, which can be used for stable indirection.
alloc(edit any[]) -> (edit any[])
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/array.s line 28
Allocates an empty buffer and zero-initializes it. This is stable with regards to pointers,
as it never reallocates an allocation. For convenience for usage within loops, allocation
of the same size only zero-initializes the buffer. If a different size is given, and the
buffer is non-empty, this fails. Consider freeing the buffer first with del buffer to
allocate again, or use ‘buffer.resize new_size’ once a first non-zero allocation has been made.
This version allocates a buffer of ONE element, which can be used for stable indirection.
alloc(edit any[], "dirty") -> (edit any[])
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/array.s line 28
Allocates an empty buffer and zero-initializes it. This is stable with regards to pointers,
as it never reallocates an allocation. For convenience for usage within loops, allocation
of the same size only zero-initializes the buffer. If a different size is given, and the
buffer is non-empty, this fails. Consider freeing the buffer first with del buffer to
allocate again, or use ‘buffer.resize new_size’ once a first non-zero allocation has been made.
alloc(edit any[], nat size) -> (edit any[])
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/array.s line 28
Allocates an empty buffer and zero-initializes it. This is stable with regards to pointers,
as it never reallocates an allocation. For convenience for usage within loops, allocation
of the same size only zero-initializes the buffer. If a different size is given, and the
buffer is non-empty, this fails. Consider freeing the buffer first with del buffer to
allocate again, or use ‘buffer.resize new_size’ once a first non-zero allocation has been made.
alloc(edit any[], nat size, "dirty") -> (edit any[])
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/unsafe.s line 19
Allocates a memory of the provided size in bytes.
alloc(nat) -> (mut any ptr)
Potential errors:
Defined in: std/core/array.s line 56
For stability of data structures, this does nothing if the previous size is the same or less. If old size was zero, an error is created instead of allocating so that this does not leak resources.
resize(edit any[], nat size) -> (edit any[])
Potential errors:
Defined in: std/core/array.s line 56
For stability of data structures, this does nothing if the previous size is the same or less. If old size was zero, an error is created instead of allocating so that this does not leak resources.
resize(edit any[], nat size, "unsafe") -> (edit any[])
Potential errors:
Defined in: std/core/array.s line 74
last(any[]) -> (any ptr {follows any ptr buffer.unsafe_ptr})
Potential errors:
Defined in: std/core/array.s line 79
mutlast(edit any[]) -> (mut any ptr {follows any ptr buffer.unsafe_ptr})
Potential errors:
Defined in: std/core/allocators.s line 56
mutget(edit list, nat pos) -> (mut any ptr {follows any ptr self.buf.unsafe_ptr})
Potential errors:
Defined in: std/core/allocators.s line 56
mutget(edit circular, nat pos) -> (mut any ptr {follows any ptr self.buf.unsafe_ptr})
Potential errors:
Defined in: std/core/array.s line 84
mutget(edit any[], nat i) -> (mut any ptr {follows any ptr buffer.unsafe_ptr})
Potential errors:
Defined in: std/map.s line 33
Implemented for string or cstr keys but buffer of any values.
mutget(edit robinhood_nat_entry[], edit any[], nat key) -> (mut any ptr {follows any ptr values.unsafe_ptr})
Potential errors:
Defined in: std/map.s line 23
Implemented for string or cstr keys but buffer of any values.
mutget(edit robinhood_str_entry[], edit any[], str) -> (mut any ptr {follows any ptr values.unsafe_ptr})
Potential errors:
Defined in: std/map.s line 23
Implemented for string or cstr keys but buffer of any values.
mutget(edit robinhood_str_entry[], edit any[], cstr key) -> (mut any ptr {follows any ptr values.unsafe_ptr})
Potential errors:
Defined in: std/sci/vec.s line 44
mutget(edit vec, nat i) -> (mut float ptr)
Potential errors:
Defined in: std/sci/mat.s line 43
mutget(edit mat, nat i, nat j) -> (mut float ptr)
Potential errors:
Defined in: std/sci/coo.s line 48
mutget(edit coo, nat k) -> (mut sparse_element ptr)
Potential errors:
Defined in: std/core/string.s line 102
len(str) -> (nat)
Defined in: std/core/array.s line 94
len(any[]) -> (nat)
Defined in: std/sci/vec.s line 40
len(vec) -> (nat)
Defined in: std/core/allocators.s line 5
new() -> (new)
Defined in: std/core/string.s line 23
arena(char) -> (edit arena)
Defined in: std/core/allocators.s line 16
The position starts from 0. This structure is often used to track the size of allocated data within the buffer.
arena(edit any[]) -> (edit arena)
Defined in: std/core/allocators.s line 9
The position starts from 0. This structure is often used to track the size of allocated data within the buffer.
arena(edit any[], nat _pos) -> (edit arena)
Defined in: std/sci/vec.s line 6
arena(float) -> (edit arena)
Defined in: std/sci/vec.s line 240
arena(edit vec) -> (edit arena)
Defined in: std/core/allocators.s line 22
allocated(edit any[], nat pos) -> (edit allocated)
Defined in: std/core/allocators.s line 25
This unpacking is used to pass an arena’s state or allocated memory data as part of structural input.
status(allocated) -> (any[] {follows any ptr self.buf.unsafe_ptr}, nat)
Defined in: std/core/allocators.s line 25
This unpacking is used to pass an arena’s state or allocated memory data as part of structural input.
status(arena) -> (any[] {follows any ptr self.buf.unsafe_ptr}, nat)
Defined in: std/core/string.s line 24
circular(char) -> (edit circular)
Defined in: std/core/allocators.s line 39
circular(edit any[]) -> (edit circular)
Defined in: std/sci/vec.s line 7
circular(float) -> (edit circular)
Defined in: std/core/string.s line 25
list(char) -> (edit list)
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/allocators.s line 44
List defined over a mutable buf that is automatically managed and resized. A capacity is maintained so that resizes are not performed too frequently.
list(edit any[]) -> (edit list)
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/vec.s line 8
list(float) -> (edit list)
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/allocators.s line 97
at(edit allocated) -> (mut any ptr {follows any ptr surface.buf.unsafe_ptr})
Potential errors:
Defined in: std/hash.s line 72
at(edit robinhood_str_entry[], str) -> (mut nat)
Potential errors:
Defined in: std/hash.s line 72
at(edit robinhood_str_entry[], cstr _k) -> (mut nat)
Potential errors:
Defined in: std/hash.s line 72
at(edit robinhood_nat_entry[], nat _k) -> (mut nat)
Potential errors:
Defined in: std/sci/vec.s line 57
at(vec, nat i) -> (float)
Potential errors:
Defined in: std/sci/vec.s line 54
at(float number, nat i) -> (float)
Defined in: std/core/string.s line 25
list(char) -> (edit list)
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/string.s line 24
circular(char) -> (edit circular)
Defined in: std/core/string.s line 23
arena(char) -> (edit arena)
Defined in: std/core/allocators.s line 5
new() -> (new)
Defined in: std/core/string.s line 35
strdat(nat pos, nat length, char first) -> (nat pos, nat length, char first)
Defined in: std/mini.s line 41
strdat(nat _pos, nat _length) -> (nat16 pos, nat16 length)
Potential errors:
Defined in: std/core/string.s line 91
Defines an implicit constant buffer using the cstr’s memory data. Subsequent comparisons no longer use the underlying pointer value.
str(cstr) -> (str)
Potential errors:
Defined in: std/core/string.s line 84
The string automatically detects the first character, which is generally tracked for fewer negative indirections on negative comparisons.
str(char[], nat endpos, "from", nat pos) -> (str)
Potential errors:
Defined in: std/core/string.s line 75
The string automatically detects the first character, which is generally tracked for fewer negative indirections on negative comparisons.
str(char[], nat pos, "to", nat endpos) -> (str)
Potential errors:
Defined in: std/core/string.s line 67
The string automatically detects the first character, which is generally tracked for fewer negative indirections on negative comparisons.
str(char[], nat pos, "len", nat length) -> (str)
Potential errors:
Defined in: std/core/string.s line 63
str(str) -> (str)
Defined in: std/core/string.s line 55
str(char[]) -> (str)
Potential errors:
Defined in: std/core/string.s line 55
str(char[], nat length) -> (str)
Potential errors:
Defined in: std/core/string.s line 48
str(char[], nat dat.pos, nat dat.length, char dat.first) -> (str)
Potential errors:
Defined in: std/core/string.s line 43
str(char ptr unsafe_ptr, nat pos, nat length) -> (str)
Defined in: std/core/string.s line 39
str(char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first) -> (str)
Defined in: std/core/convertstr.s line 113
The read string is placed onto memory that keeps being reallocated to accommodate its size. The resulting memory will consume exactly the required size in bytes.
str(new CHARS, console console) -> (str) with effects CHARS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/convertstr.s line 113
The read string is placed on an arena while consuming only the necessarily minimum size.
str(edit arena, console console) -> (str) with effects CHARS
Potential errors:
Defined in: std/mini.s line 54
The created str variation should be used only for storng and retrieving data with ‘unpack’ for memory efficiency.
str(cstr) -> (str)
Potential errors:
Defined in: std/mini.s line 46
The created str variation should be used only for storng and retrieving data with ‘unpack’ for memory efficiency.
str(str) -> (str)
Potential errors:
Defined in: std/core/string.s line 129
copy(edit list, cstr _other) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 129
copy(edit list, str) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 129
copy(edit circular, cstr _other) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 129
copy(edit circular, str) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 129
copy(edit arena, cstr _other) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 129
copy(edit arena, str) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 129
copy(new CHARS, cstr _other) -> (str) with effects CHARS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/string.s line 129
copy(new CHARS, str) -> (str) with effects CHARS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/vec.s line 232
Grabs a FLOATS for the result as an effect.
copy(edit circular, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 232
Grabs a FLOATS for the result as an effect.
copy(edit arena, vec) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 232
Grabs a FLOATS for the result as an effect.
copy(new FLOATS, vec) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/string.s line 136
Copies a string to a new buffer while ensuring null termination. This is mainly useful for supporting ‘cstr unsafe_temp’.
copy_null_terminated(new CHARS, str) -> (str) with effects CHARS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/string.s line 217
Constructs the copy on the buffer at a given position and returns it.
The position is mutated to indicate where the string ends (e.g., to copy more strings).
This operation may fail if the string does not fit the current allocation - prefer copying on a list mut char[] instead.
copy_null_terminated(edit arena, cstr _other) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 217
Constructs the copy on the buffer at a given position and returns it.
The position is mutated to indicate where the string ends (e.g., to copy more strings).
This operation may fail if the string does not fit the current allocation - prefer copying on a list mut char[] instead.
copy_null_terminated(edit arena, str) -> (str) with effects CHARS
Potential errors:
Defined in: std/core/string.s line 168
This is mainly used as a stt-input counterpart for converting str|cstr to cstr.
unsafe_temp(cstr) -> (cstr cstr, str)
Potential errors:
Defined in: std/core/string.s line 146
This function’s return is meant to be passed to operating system calls, or return from compt with the pattern ‘cstr unsafetemp stringvalue’. It will become invalid once the calling site ends. It also does not admit proper cstr equality comparisons via pointer values that reflect contents; it will always compare equal only to itself. An optimization that safely checks the last element and one position beyond the buffer’s contents for null termination is also employed. Modifying the string buffer in any capacity invalidates the null termination property, so in general do not manipulate strings while this is used in code; use it only for its intended purposes.
unsafe_temp(str) -> (unsafe_temp)
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/string.s line 180
This position is computed relative to its start in its enclosing buffer.
endpos(str) -> (nat)
Defined in: std/core/string.s line 252
slice(str, nat from, nat to) -> (str)
Potential errors:
Defined in: std/core/string.s line 252
slice(cstr _s, nat from, nat to) -> (str)
Potential errors:
Defined in: std/core/string.s line 261
starts_with(cstr _stack, cstr _needle) -> (bool)
Potential errors:
Defined in: std/core/string.s line 261
starts_with(cstr _stack, str) -> (bool)
Potential errors:
Defined in: std/core/string.s line 261
starts_with(str, str) -> (bool)
Potential errors:
Defined in: std/core/string.s line 261
starts_with(str, cstr _needle) -> (bool)
Potential errors:
Defined in: std/core/string.s line 268
ends_with(str, str) -> (bool)
Potential errors:
Defined in: std/core/string.s line 268
ends_with(str, cstr _needle) -> (bool)
Potential errors:
Defined in: std/core/string.s line 268
ends_with(cstr _stack, str) -> (bool)
Potential errors:
Defined in: std/core/string.s line 268
ends_with(cstr _stack, cstr _needle) -> (bool)
Potential errors:
Defined in: std/core/string.s line 284
contains(str, str) -> (bool)
Potential errors:
Defined in: std/core/string.s line 284
contains(str, cstr _needle) -> (bool)
Potential errors:
Defined in: std/core/string.s line 284
contains(cstr _stack, str) -> (bool)
Potential errors:
Defined in: std/core/string.s line 284
contains(cstr _stack, cstr _needle) -> (bool)
Potential errors:
Defined in: std/core/string.s line 277
contains(str, char needle) -> (bool)
Potential errors:
Defined in: std/core/string.s line 277
contains(cstr _stack, char needle) -> (bool)
Potential errors:
Defined in: std/core/convertstr.s line 30
is_number(char) -> (bool)
Defined in: std/rand.s line 26
rotl(nat x, nat k) -> (nat)
Defined in: std/rand.s line 55
Computes the seed of a splitmix64 sequence using the clock as the source of entropy.
splitmix64() -> (nat)
[time.time_ns()]Defined in: std/rand.s line 33
Computes the next random number of a splitmix64 sequence using the mutable unsigned int argument as state to be updated. This is NOT cryptographically secure and also has small period of 2^64 so usage is not recommended for long-running sequences. It is, however, faster than computing a next Rand state with next. If you do not provide a seed, a number obtained from the current time is provided. That can only be the start of a sequence, and marked as a leaking resource to prevent time-based randomization (which is not random).
splitmix64(mut nat) -> (mut nat)
Defined in: std/rand.s line 80
Xoshiro256plus random numbers from https://prng.di.unimi.it/ These and are NOT cryptographically secure. This a structural type for storing the progress of random number generators on four u64 state fields. This version defaults to a time-based seed. Its period is 2^256-1.
Rand() -> (edit Rand)
Defined in: std/rand.s line 65
Xoshiro256plus random numbers from https://prng.di.unimi.it/ These and are NOT cryptographically secure. This a structural type for storing the progress of random number generators on four u64 state fields. The version is seed-initalized. Its period is 2^256-1.
Rand(nat) -> (edit Rand)
Defined by the compiler
Represents values in the range 0 to 2^64-1.
nat() -> (nat)
Defined by the compiler
float() -> (float)
Defined by the compiler
cstr() -> (cstr)
Defined in: std/core/convert.s line 95
Converts a bit representation to the corresponding float number.
float(bits) -> (float)
Defined in: std/core/convert.s line 84
Converts a bit representation to the corresponding natural number.
nat(bits) -> (nat)
Defined in: std/core/convert.s line 51
Converting a character to a natural number considers its bit representation interpreted as an unsigned number.
nat(char) -> (nat)
Defined in: std/core/convert.s line 40
Converting to natural numbers loses information. Failed on negative input because it typically indicates a later error in buffer indexing.
nat(nat) -> (nat)
Defined in: std/core/convert.s line 40
Converting to natural numbers loses information. Failed on negative input because it typically indicates a later error in buffer indexing.
nat(int) -> (nat)
Potential errors:
Defined in: std/core/convert.s line 40
Converting to natural numbers loses information. Failed on negative input because it typically indicates a later error in buffer indexing.
nat(float) -> (nat)
Potential errors:
Defined in: std/core/convert.s line 20
May lose information because floats are not exact representation of all integers.
float(nat) -> (float)
Defined in: std/core/convert.s line 20
May lose information because floats are not exact representation of all integers.
float(int) -> (float)
Defined in: std/core/convert.s line 20
Serves as a tautology function for code that parses on multiple number types.
float(float) -> (float)
Defined in: std/core/string.s line 174
This function’s return is meant to be passed to operating system calls, or to comptime returns with the pattern ‘cstr unsafetemp stringvalue’.
cstr(cstr cstr, str) -> (cstr)
Defined in: std/core/string.s line 174
This function’s return is meant to be passed to operating system calls, or to comptime returns with the pattern ‘cstr unsafetemp stringvalue’.
cstr(unsafe_temp) -> (cstr)
Defined in: std/core/string.s line 91
Defines an implicit constant buffer using the cstr’s memory data. Subsequent comparisons no longer use the underlying pointer value.
str(cstr) -> (str)
Potential errors:
Defined in: std/core/string.s line 84
The string automatically detects the first character, which is generally tracked for fewer negative indirections on negative comparisons.
str(char[], nat endpos, "from", nat pos) -> (str)
Potential errors:
Defined in: std/core/string.s line 75
The string automatically detects the first character, which is generally tracked for fewer negative indirections on negative comparisons.
str(char[], nat pos, "to", nat endpos) -> (str)
Potential errors:
Defined in: std/core/string.s line 67
The string automatically detects the first character, which is generally tracked for fewer negative indirections on negative comparisons.
str(char[], nat pos, "len", nat length) -> (str)
Potential errors:
Defined in: std/core/string.s line 63
str(str) -> (str)
Defined in: std/core/string.s line 55
str(char[]) -> (str)
Potential errors:
Defined in: std/core/string.s line 55
str(char[], nat length) -> (str)
Potential errors:
Defined in: std/core/string.s line 48
str(char[], nat dat.pos, nat dat.length, char dat.first) -> (str)
Potential errors:
Defined in: std/core/string.s line 43
str(char ptr unsafe_ptr, nat pos, nat length) -> (str)
Defined in: std/core/string.s line 39
str(char ptr unsafe_ptr, nat dat.pos, nat dat.length, char dat.first) -> (str)
Defined in: std/core/array.s line 24
nat(nat16) -> (nat)
Defined in: std/core/convertstr.s line 113
The read string is placed onto memory that keeps being reallocated to accommodate its size. The resulting memory will consume exactly the required size in bytes.
str(new CHARS, console console) -> (str) with effects CHARS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/error.s line 19
Error codes should not be compared numerically against given numbers, as their numbering changes for different programs. Instead, they should be converted to a cstr string with this function, which can then be compared. This comparison is also one numerical comparison, as care is taken for all cstr to point to the same memory location.
cstr(catch) -> (cstr)
Defined in: std/core/convertstr.s line 113
The read string is placed on an arena while consuming only the necessarily minimum size.
str(edit arena, console console) -> (str) with effects CHARS
Potential errors:
Defined in: std/hash.s line 7
hash(str, nat size) -> (nat)
Potential errors:
Defined in: std/hash.s line 13
hash(nat k, nat size) -> (nat)
Potential errors:
Defined in: std/hash.s line 27
to_hash_base(nat) -> (bits)
Defined in: std/hash.s line 27
to_hash_base(int) -> (bits)
Defined in: std/hash.s line 27
to_hash_base(float) -> (bits)
Defined in: std/hash.s line 24
to_hash_base(cstr) -> (str)
Potential errors:
Defined in: std/hash.s line 24
to_hash_base(str) -> (str)
Defined in: std/hash.s line 30
robinhood_str_entry(str, nat cost) -> (str, nat cost)
Defined in: std/hash.s line 33
robinhood_nat_entry(nat s, nat cost) -> (nat s, nat cost)
Defined in: std/hash.s line 33
robinhood_nat_entry(nat s, nat cost) -> (nat s, nat cost)
Defined in: std/hash.s line 30
robinhood_str_entry(str, nat cost) -> (str, nat cost)
Defined in: std/hash.s line 44
raw(cstr) -> (str)
Potential errors:
Defined in: std/hash.s line 41
raw(nat) -> (nat)
Defined in: std/hash.s line 41
raw(str) -> (str)
Defined in: std/hash.s line 38
raw(nat s, nat cost) -> (nat)
Defined in: std/hash.s line 38
raw(str, nat cost) -> (str)
Defined in: std/hash.s line 50
is_zero(nat) -> (bool)
Defined in: std/hash.s line 47
is_zero(str) -> (bool)
Defined in: std/hash.s line 53
find(nat[], nat _k) -> (mut nat)
Potential errors:
Defined in: std/hash.s line 53
find(robinhood_nat_entry[], nat _k) -> (mut nat)
Potential errors:
Defined in: std/hash.s line 53
find(str[], cstr _k) -> (mut nat)
Potential errors:
Defined in: std/hash.s line 53
find(robinhood_str_entry[], str) -> (mut nat)
Potential errors:
Defined in: std/hash.s line 53
find(str[], str) -> (mut nat)
Potential errors:
Defined in: std/hash.s line 53
find(robinhood_str_entry[], cstr _k) -> (mut nat)
Potential errors:
Defined in: std/map.s line 4
Maps string indexes to the buffer provided using a robinhood scheme. Map size is static and cannot be adjusted after initialization.
strmap(edit any[]) -> (mut robinhood_str_entry[], edit any[])
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/map.s line 11
Maps number indexes to the buffer provided using a robinhood scheme. Map size is static and cannot be adjusted after initialization.
natmap(edit any[]) -> (mut robinhood_nat_entry[], edit any[])
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/mini.s line 66
unpack(char[], nat16 dat.pos, nat16 dat.length) -> (str)
Potential errors:
Defined in: std/mini.s line 60
The created compact str is unpacked into its ’nat’-using representation that is more efficient for computations in 64-bit architectures.
unpack(str) -> (str)
Defined in: std/sci/math.s line 9
abs(int) -> (nat)
[abs($x)]Defined in: std/sci/math.s line 4
abs(float) -> (float)
[abs($x)]Defined in: std/sci/math.s line 14
sqrt(float) -> (float)
Defined in: std/sci/math.s line 18
sin(float) -> (float)
Defined in: std/sci/math.s line 22
cos(float) -> (float)
Defined in: std/sci/math.s line 26
log(float) -> (float)
Defined in: std/sci/math.s line 30
tan(float) -> (float)
Defined in: std/sci/math.s line 34
floor(float) -> (int)
Defined in: std/sci/math.s line 38
asin(float) -> (float)
Defined in: std/sci/math.s line 42
acos(float) -> (float)
Defined in: std/sci/math.s line 50
atan(float x, float y) -> (float)
Defined in: std/sci/math.s line 46
atan(float) -> (float)
Defined in: std/sci/math.s line 54
exp(float) -> (float)
Defined in: std/sci/math.s line 63
isnan(float) -> (bool)
[math.isnan(x)]Defined in: std/sci/math.s line 68
isinf(float) -> (bool)
[math.isinf(x)]Defined in: std/sci/vec.s line 31
vec(edit circular, nat length) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 31
vec(edit circular, nat length, "dirty") -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 31
vec(edit arena, nat length) -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 31
vec(edit arena, nat length, "dirty") -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/vec.s line 19
vec(edit float[]) -> (mut vec)
Potential errors:
Defined in: std/sci/vec.s line 11
Has the provided length. Requires a ’new()’ allocator to denote that the vector will be placed on a new buffer.
vec(new FLOATS, nat length) -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/vec.s line 11
Has the provided length. Requires a ’new()’ allocator to denote that the vector will be placed on a new buffer.
vec(new FLOATS, nat length, "dirty") -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/unsafe.s line 3
Warning: directly calling this constructor without safety checks is unsafe.
vec(float ptr unsafe_ptr, nat pos, nat length) -> (mut vec)
Defined in: std/sci/mat.s line 65
vec(mat) -> (mut vec)
Defined in: std/sci/unsafe.s line 8
Warning: directly calling this constructor without safety checks is unsafe.
mat(float ptr unsafe_ptr, nat pos, nat rows, nat cols, nat stride) -> (mut mat)
Defined in: std/sci/mat.s line 55
A ‘type "row"’ or ‘type "col"’ marker is needed to indicate the new matrix’s orientation.
mat(vec, "col") -> (mut mat)
Defined in: std/sci/mat.s line 55
A ‘type "row"’ or ‘type "col"’ marker is needed to indicate the new matrix’s orientation.
mat(vec, "row") -> (mut mat)
Defined in: std/sci/mat.s line 37
mat(edit float[], nat rows) -> (mut mat)
Potential errors:
Defined in: std/sci/mat.s line 21
mat(edit circular, nat rows, nat cols) -> (mut mat) with effects FLOATS
Potential errors:
Defined in: std/sci/mat.s line 21
mat(edit circular, nat rows, nat cols, "dirty") -> (mut mat) with effects FLOATS
Potential errors:
Defined in: std/sci/mat.s line 21
mat(edit arena, nat rows, nat cols) -> (mut mat) with effects FLOATS
Potential errors:
Defined in: std/sci/mat.s line 21
mat(edit arena, nat rows, nat cols, "dirty") -> (mut mat) with effects FLOATS
Potential errors:
Defined in: std/sci/mat.s line 14
mat(new FLOATS, nat rows, nat cols) -> (mut mat) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/mat.s line 14
mat(new FLOATS, nat rows, nat cols, "dirty") -> (mut mat) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/unsafe.s line 13
sparse_element(nat row, nat col, float value) -> (nat row, nat col, float value)
Defined in: std/sci/unsafe.s line 14
Warning: directly calling this constructor without safety checks is unsafe.
coo(sparse_element ptr unsafe_ptr, nat rows, nat cols, nat nnz) -> (mut coo)
Defined in: std/sci/coo.s line 40
coo(sparse_element[], nat rows, nat cols) -> (mut coo)
Defined in: std/sci/coo.s line 34
This creates a new buffer of sparse elements for convenience.
coo(nat rows, nat cols, nat nnz) -> (mut coo)
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/core/allocators.s line 5
new() -> (new)
Defined in: std/sci/vec.s line 7
circular(float) -> (edit circular)
Defined in: std/sci/vec.s line 6
arena(float) -> (edit arena)
Defined in: std/sci/vec.s line 25
constvec(float[]) -> (vec)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "rel", vec, "add") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "rel", vec, "l2") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "rel", vec, "sqr") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "rel", vec, "abs") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "rel", vec) -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "sub", vec, "mul", "l2") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "sub", vec, "mul", "sqr") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "sub", vec, "mul", "abs") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "sub", vec, "mul") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "sub", vec, "add", "l2") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "sub", vec, "add", "sqr") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "sub", vec, "add", "abs") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "sub", vec, "add") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "sub", vec, "l2") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "sub", vec, "sqr") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "sub", vec, "abs") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "sub", vec) -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "mul", vec, "mul", "l2") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "mul", vec, "mul", "sqr") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "mul", vec, "mul", "abs") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "mul", vec, "mul") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "mul", vec, "add", "l2") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "mul", vec, "add", "sqr") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "mul", vec, "add", "abs") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "mul", vec, "add") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "mul", vec, "l2") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "mul", vec, "sqr") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "mul", vec, "abs") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "mul", vec) -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, vec, "mul", "l2") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, vec, "mul", "sqr") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, vec, "mul", "abs") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, vec, "mul") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, vec, "add", "l2") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, vec, "add", "sqr") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, vec, "add", "abs") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, vec, "add") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, vec, "l2") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, vec, "sqr") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, vec, "abs") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, vec) -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "mul", "l2") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "mul", "sqr") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "mul", "abs") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "mul") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "add", "l2") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "add", "sqr") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "add", "abs") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "add") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "l2") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "sqr") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "abs") -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec) -> (float)
No failing errors, but can catch these intercepted ones:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "rel", vec, "mul", "l2") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "rel", vec, "mul", "sqr") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "rel", vec, "mul", "abs") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "rel", vec, "mul") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "rel", vec, "add", "l2") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "rel", vec, "add", "sqr") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 151
You can specify an additive or multiplicative reduction, as well as some transformation that can be applied. A second vector can also be provided to be subtracted or obtain relative value differences without allocating any memory for operation results. All computations are branchless, as literals are optimized away during compilation.
reduce(vec, "rel", vec, "add", "abs") -> (float)
Potential errors:
Defined in: std/sci/vec.s line 187
dot(vec, vec) -> (float)
Potential errors:
Defined in: std/sci/vec.s line 191
sum(vec) -> (float)
Defined in: std/sci/coo.s line 109
result[j] = sum of all stored values in column j
sum(edit circular, coo, "col") -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/coo.s line 109
result[j] = sum of all stored values in column j
sum(edit arena, coo, "col") -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/coo.s line 109
result[j] = sum of all stored values in column j
sum(new FLOATS, coo, "col") -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/coo.s line 101
result[i] = sum of all stored values in row i
sum(edit circular, coo, "row") -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/coo.s line 101
result[i] = sum of all stored values in row i
sum(edit arena, coo, "row") -> (mut vec) with effects FLOATS
Potential errors:
Defined in: std/sci/coo.s line 101
result[i] = sum of all stored values in row i
sum(new FLOATS, coo, "row") -> (mut vec) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/vec.s line 195
mean(vec) -> (float)
Potential errors:
Defined in: std/sci/vec.s line 199
var(vec) -> (float)
Potential errors:
Defined in: std/sci/vec.s line 210
std(vec) -> (float)
Potential errors:
Defined in: std/sci/vec.s line 247
self(edit vec) -> (edit arena, edit vec)
Defined in: std/sci/mat.s line 6
rows(mat) -> (nat)
Defined in: std/sci/coo.s line 22
rows(coo) -> (nat)
Defined in: std/sci/mat.s line 10
cols(mat) -> (nat)
Defined in: std/sci/coo.s line 26
cols(coo) -> (nat)
Defined in: std/sci/mat.s line 31
constmat(float[], nat rows) -> (mat)
Potential errors:
Defined in: std/sci/mat.s line 69
mutvec(mat) -> (mut vec)
Defined in: std/sci/mat.s line 73
row(mat, nat i) -> (mut vec)
Potential errors:
Defined in: std/sci/coo.s line 30
nnz(coo) -> (nat)
Defined in: std/sci/coo.s line 80
todense(edit circular, coo) -> (mut mat) with effects FLOATS
Potential errors:
Defined in: std/sci/coo.s line 80
todense(edit arena, coo) -> (mut mat) with effects FLOATS
Potential errors:
Defined in: std/sci/coo.s line 80
todense(new FLOATS, coo) -> (mut mat) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/unsafe.s line 14
Warning: directly calling this constructor without safety checks is unsafe.
coo(sparse_element ptr unsafe_ptr, nat rows, nat cols, nat nnz) -> (mut coo)
Defined in: std/sci/unsafe.s line 8
Warning: directly calling this constructor without safety checks is unsafe.
mat(float ptr unsafe_ptr, nat pos, nat rows, nat cols, nat stride) -> (mut mat)
Defined in: std/sci/mat.s line 55
A ‘type "row"’ or ‘type "col"’ marker is needed to indicate the new matrix’s orientation.
mat(vec, "col") -> (mut mat)
Defined in: std/sci/mat.s line 55
A ‘type "row"’ or ‘type "col"’ marker is needed to indicate the new matrix’s orientation.
mat(vec, "row") -> (mut mat)
Defined in: std/sci/mat.s line 37
mat(edit float[], nat rows) -> (mut mat)
Potential errors:
Defined in: std/sci/mat.s line 21
mat(edit circular, nat rows, nat cols) -> (mut mat) with effects FLOATS
Potential errors:
Defined in: std/sci/mat.s line 21
mat(edit circular, nat rows, nat cols, "dirty") -> (mut mat) with effects FLOATS
Potential errors:
Defined in: std/sci/mat.s line 21
mat(edit arena, nat rows, nat cols) -> (mut mat) with effects FLOATS
Potential errors:
Defined in: std/sci/mat.s line 21
mat(edit arena, nat rows, nat cols, "dirty") -> (mut mat) with effects FLOATS
Potential errors:
Defined in: std/sci/mat.s line 14
mat(new FLOATS, nat rows, nat cols) -> (mut mat) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/mat.s line 14
mat(new FLOATS, nat rows, nat cols, "dirty") -> (mut mat) with effects FLOATS
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/sci/coo.s line 40
coo(sparse_element[], nat rows, nat cols) -> (mut coo)
Defined in: std/sci/coo.s line 34
This creates a new buffer of sparse elements for convenience.
coo(nat rows, nat cols, nat nnz) -> (mut coo)
Potential errors:
Returned values defer use of the following functions:
exists(any ptr) -> (bool)
free(mut any ptr) -> ()
Defined in: std/unsafe.s line 28
Reallocates an allocated memory pointer, potentially invalidating the original one without any safety.
realloc(any ptr allocated, nat bytes) -> (any ptr {follows any ptr allocated})
Potential errors:
Defined in: std/unsafe.s line 40
Frees allocated memory.
free(mut any ptr) -> ()
Defined in: std/unsafe.s line 47
Memsets a memory region to zero.
zero(any ptr allocated, nat from, nat to) -> ()