| print(x: string) | output any value to the console (with linefeed). |
| string(x: string) -> string | convert any value to string |
| set_print_depth(depth: int) -> int | for printing / string conversion: sets max vectors/objects recursion depth (default 10), returns old value |
| set_print_length(len: int) -> int | for printing / string conversion: sets max string length (default 100000), returns old value |
| set_print_quoted(quoted: bool) -> int | for printing / string conversion: if the top level value is a string, whether to convert it with escape codes and quotes (default false), returns old value |
| set_print_decimals(decimals: int) -> int | for printing / string conversion: number of decimals for any floating point output (default -1, meaning all), returns old value |
| set_print_indent(spaces: int) -> int | for printing / string conversion: number of spaces to indent with. default is 0: no indent / no multi-line, returns old value |
| get_line(prefix: string) -> string | reads a string from the console if possible (followed by enter). Prefix will be printed before the input |
| append(xs: [any], ys: [any]) -> [any] | creates a new vector by appending all elements of 2 input vectors |
| append_into(dest: [any], src: [any]) -> [any] | appends all elements of the second vector into the first |
| vector_capacity(xs: [any], len: int) -> [any] | ensures the vector capacity (number of elements it can contain before re-allocating) is at least "len". Does not actually add (or remove) elements. This function is just for efficiency in the case the amount of "push" operations is known. returns original vector. |
| length(x: int) -> int | length of int (identity function, useful in combination with string/vector version) |
| length(s: string) -> int | length of string |
| length(xs: [any]) -> int | length of vector |
| equal(a: any, b: any) -> int | structural equality between any two values (recurses into vectors/objects, unlike == which is only true for vectors/objects if they are the same object) |
| push(xs: [any], x: any) -> [any] | appends one element to a vector, returns existing vector |
| pop(xs: [any]) -> any | removes last element from vector and returns it |
| top(xs: [any]) -> any | returns last element from vector |
| insert(xs: [any], i: int, x: any) -> [any] | inserts a value into a vector at index i, existing elements shift upward, returns original vector |
| remove(xs: [any], i: int) -> any | remove element at index i, following elements shift down. returns the element removed. |
| remove_range(xs: [any], i: int, n: int) | remove n elements at index i, following elements shift down. |
| remove_obj(xs: [any], obj: any) -> any | remove all elements equal to obj (==), returns obj. |
| truncate(xs: [any], i: int) | removes all elements starting from index i, does nothing if i >= len |
| binary_search(xs: [int], key: int) -> int, int | does a binary search for key in a sorted vector, returns as first return value how many matches were found, and as second the index in the array where the matches start (so you can read them, overwrite them, or remove them), or if none found, where the key could be inserted such that the vector stays sorted. This overload is for int vectors and keys. |
| binary_search(xs: [float], key: float) -> int, int | float version. |
| binary_search(xs: [string], key: string) -> int, int | string version. |
| binary_search_object(xs: [any], key: any) -> int, int | object version. compares by reference rather than contents. |
| binary_search_first_field_string(xs: [any], key: string) -> int, int | object version where key is the first field (must be string, runtime error if it is not) |
| binary_search_first_field_object(xs: [any], key: any) -> int, int | object version where key is the first field (must be object, runtime error if it is not) |
| copy(x: any) -> any | makes a shallow copy of any object/vector/string. |
| deepcopy(x: any, depth: int) -> any | makes a deep copy of any object/vector/string. DAGs become trees, and cycles will clone until it reach the given depth. depth == 1 would do the same as copy. |
| slice(xs: [any], start: int, size: int) -> [any] | returns a sub-vector of size elements from index start. size can be negative to indicate the rest of the vector. |
| any(xs: [any]) -> int | returns whether any elements of the vector are true values |
| any(xs: int1) -> int | returns whether any elements of the numeric struct are true values |
| any(xs: int2) -> int | returns whether any elements of the numeric struct are true values |
| any(xs: int3) -> int | returns whether any elements of the numeric struct are true values |
| any(xs: int4) -> int | returns whether any elements of the numeric struct are true values |
| all(xs: [any]) -> int | returns whether all elements of the vector are true values |
| all(xs: int1) -> int | returns whether all elements of the numeric struct are true values |
| all(xs: int2) -> int | returns whether all elements of the numeric struct are true values |
| all(xs: int3) -> int | returns whether all elements of the numeric struct are true values |
| all(xs: int4) -> int | returns whether all elements of the numeric struct are true values |
| substring(s: string, start: int, size: int) -> string | returns a substring of size characters from index start. size can be negative to indicate the rest of the string. |
| find_string(s: string, substr: string, offset: int = 0) -> int | finds the index at which substr first appears, or -1 if none. optionally start at a position other than 0 |
| find_string_reverse(s: string, substr: string, offset: int = 0) -> int | finds the index at which substr first appears when searching from the end, or -1 if none. optionally start at a position other than the end of the string |
| split_string(s: string, delimiter: string) -> string, string | returns two strings, the parts of the input before and after the first delimiter. if not found, returns the input and an empty string |
| split_string_reverse(s: string, delimiter: string) -> string, string | returns two strings, the parts of the input before and after the last delimiter. if not found, returns an empty string and the input |
| replace_string(s: string, a: string, b: string, count: int = 0) -> string | returns a copy of s where all occurrences of a have been replaced with b. if a is empty, no replacements are made. if count is specified, makes at most that many replacements |
| string_to_int(s: string, base: int = 0) -> int, int | converts a string to an int given the base (2..36, e.g. 16 for hex, default is 10).returns 0 if no numeric data could be parsed (or overflow); second return value is true if allcharacters of the string were parsed (and no overflow). |
| string_to_float(s: string) -> float, int | converts a string to a float. returns 0.0 if no numeric data could be parsed;second return value is true if all characters of the string were parsed. |
| tokenize(s: string, delimiters: string, whitespace: string, dividing: int = 0) -> [string] | splits a string into a vector of strings, by splitting into segments upon each dividing or terminating delimiter. Segments are stripped of leading and trailing whitespace. Example: "; A ; B C;; " becomes [ "", "A", "B C", "" ] with ";" as delimiter and " " as whitespace. If dividing was true, there would be a 5th empty string element. |
| unicode_to_string(us: [int]) -> string | converts a vector of ints representing unicode values to a UTF-8 string. |
| string_to_unicode(s: string) -> [int], int | converts a UTF-8 string into a vector of unicode values. second return value is false if there was a decoding error, and the vector will only contain the characters up to the error |
| number_to_string(number: int, base: int, minchars: int) -> string | converts the (unsigned version) of the input integer number to a string given the base (2..36, e.g. 16 for hex) and outputting a minimum of characters (padding with 0). |
| lowercase(s: string) -> string | converts a UTF-8 string from any case to lower case, affecting only A-Z |
| uppercase(s: string) -> string | converts a UTF-8 string from any case to upper case, affecting only a-z |
| escape_string(s: string, set: string, prefix: string, postfix: string) -> string | prefixes & postfixes any occurrences or characters in set in string s |
| concat_string(v: [string], sep: string) -> string | concatenates all elements of the string vector, separated with sep. |
| repeat_string(s: string, n: int) -> string | returns a string consisting of n copies of the input string. |
| string_with_capacity(capacity: int) -> string | an empty string with room to grow to capacity bytes without moving, for use as a byte buffer (see write_int64_le) or to build up with +=. A string that fits in a small allocation gets at most the room such an allocation has (a few hundred bytes). |
| pow(a: int, b: int) -> int | a raised to the power of b, for integers, using exponentiation by squaring |
| pow(a: float, b: float) -> float | a raised to the power of b |
| pow(a: float2, b: float) -> float2 | struct elements raised to the power of b |
| pow(a: float3, b: float) -> float3 | struct elements raised to the power of b |
| pow(a: float4, b: float) -> float4 | struct elements raised to the power of b |
| log(a: float) -> float | natural logaritm of a |
| log2(a: float) -> float | base 2 logaritm of a |
| sqrt(f: float) -> float | square root |
| ceiling(f: float) -> int | the nearest int >= f |
| ceiling(v: float1) -> int1 | the nearest ints >= each component of v |
| ceiling(v: float2) -> int2 | the nearest ints >= each component of v |
| ceiling(v: float3) -> int3 | the nearest ints >= each component of v |
| ceiling(v: float4) -> int4 | the nearest ints >= each component of v |
| floor(f: float) -> int | the nearest int <= f |
| floor(v: float1) -> int1 | the nearest ints <= each component of v |
| floor(v: float2) -> int2 | the nearest ints <= each component of v |
| floor(v: float3) -> int3 | the nearest ints <= each component of v |
| floor(v: float4) -> int4 | the nearest ints <= each component of v |
| int(f: float) -> int | converts a float to an int by dropping the fraction |
| int(v: float1) -> int1 | converts a struct of floats to ints by dropping the fraction |
| int(v: float2) -> int2 | converts a struct of floats to ints by dropping the fraction |
| int(v: float3) -> int3 | converts a struct of floats to ints by dropping the fraction |
| int(v: float4) -> int4 | converts a struct of floats to ints by dropping the fraction |
| round(f: float) -> int | converts a float to the closest int |
| round(v: float1) -> int1 | converts a struct of floats to the closest ints |
| round(v: float2) -> int2 | converts a struct of floats to the closest ints |
| round(v: float3) -> int3 | converts a struct of floats to the closest ints |
| round(v: float4) -> int4 | converts a struct of floats to the closest ints |
| fraction(f: float) -> float | returns the fractional part of a float: short for f - floor(f) |
| fraction(v: float1) -> float1 | returns the fractional part of a struct of floats |
| fraction(v: float2) -> float2 | returns the fractional part of a struct of floats |
| fraction(v: float3) -> float3 | returns the fractional part of a struct of floats |
| fraction(v: float4) -> float4 | returns the fractional part of a struct of floats |
| float(i: int) -> float | converts an int to float |
| float(v: int1) -> float1 | converts a struct of ints to floats |
| float(v: int2) -> float2 | converts a struct of ints to floats |
| float(v: int3) -> float3 | converts a struct of ints to floats |
| float(v: int4) -> float4 | converts a struct of ints to floats |
| sin(angle: float) -> float | the y coordinate of the normalized vector indicated by angle (in degrees) |
| sin(angle: float1) -> float1 | the y coordinates of the normalized vector indicated by the angles (in degrees) |
| sin(angle: float2) -> float2 | the y coordinates of the normalized vector indicated by the angles (in degrees) |
| sin(angle: float3) -> float3 | the y coordinates of the normalized vector indicated by the angles (in degrees) |
| sin(angle: float4) -> float4 | the y coordinates of the normalized vector indicated by the angles (in degrees) |
| cos(angle: float) -> float | the x coordinate of the normalized vector indicated by angle (in degrees) |
| cos(angle: float1) -> float1 | the x coordinates of the normalized vector indicated by the angles (in degrees) |
| cos(angle: float2) -> float2 | the x coordinates of the normalized vector indicated by the angles (in degrees) |
| cos(angle: float3) -> float3 | the x coordinates of the normalized vector indicated by the angles (in degrees) |
| cos(angle: float4) -> float4 | the x coordinates of the normalized vector indicated by the angles (in degrees) |
| tan(angle: float) -> float | the tangent of an angle (in degrees) |
| tan(angle: float1) -> float1 | the tangents of the angles (in degrees) |
| tan(angle: float2) -> float2 | the tangents of the angles (in degrees) |
| tan(angle: float3) -> float3 | the tangents of the angles (in degrees) |
| tan(angle: float4) -> float4 | the tangents of the angles (in degrees) |
| sincos(angle: float) -> float2 | the normalized vector indicated by angle (in degrees), same as float2 { cos(angle), sin(angle) } |
| asin(y: float) -> float | the angle (in degrees) indicated by the y coordinate projected to the unit circle |
| acos(x: float) -> float | the angle (in degrees) indicated by the x coordinate projected to the unit circle |
| atan(x: float) -> float | the angle (in degrees) indicated by the y coordinate of the tangent projected to the unit circle |
| radians(angle: float) -> float | converts an angle in degrees to radians |
| degrees(angle: float) -> float | converts an angle in radians to degrees |
| atan2(vec: float2) -> float | the angle (in degrees) corresponding to a normalized 2D vector |
| normalize(vec: float1) -> float1 | returns a vector of unit length |
| normalize(vec: float2) -> float2 | returns a vector of unit length |
| normalize(vec: float3) -> float3 | returns a vector of unit length |
| normalize(vec: float4) -> float4 | returns a vector of unit length |
| dot(a: float1, b: float1) -> float | the length of vector a when projected onto b (or vice versa) |
| dot(a: float2, b: float2) -> float | the length of vector a when projected onto b (or vice versa) |
| dot(a: float3, b: float3) -> float | the length of vector a when projected onto b (or vice versa) |
| dot(a: float4, b: float4) -> float | the length of vector a when projected onto b (or vice versa) |
| magnitude(v: float1) -> float | the geometric length of a vector |
| magnitude(v: float2) -> float | the geometric length of a vector |
| magnitude(v: float3) -> float | the geometric length of a vector |
| magnitude(v: float4) -> float | the geometric length of a vector |
| magnitude_squared(v: float1) -> float | the geometric length of a vector squared |
| magnitude_squared(v: float2) -> float | the geometric length of a vector squared |
| magnitude_squared(v: float3) -> float | the geometric length of a vector squared |
| magnitude_squared(v: float4) -> float | the geometric length of a vector squared |
| magnitude_squared(v: int1) -> int | the geometric length of a vector squared |
| magnitude_squared(v: int2) -> int | the geometric length of a vector squared |
| magnitude_squared(v: int3) -> int | the geometric length of a vector squared |
| magnitude_squared(v: int4) -> int | the geometric length of a vector squared |
| manhattan(v: int1) -> int | the manhattan distance of a vector |
| manhattan(v: int2) -> int | the manhattan distance of a vector |
| manhattan(v: int3) -> int | the manhattan distance of a vector |
| manhattan(v: int4) -> int | the manhattan distance of a vector |
| cross(a: float3, b: float3) -> float3 | a perpendicular vector to the 2D plane defined by a and b (swap a and b for its inverse) |
| volume(v: float1) -> float | the volume of the area spanned by the vector |
| volume(v: float2) -> float | the volume of the area spanned by the vector |
| volume(v: float3) -> float | the volume of the area spanned by the vector |
| volume(v: float4) -> float | the volume of the area spanned by the vector |
| volume(v: int1) -> int | the volume of the area spanned by the vector |
| volume(v: int2) -> int | the volume of the area spanned by the vector |
| volume(v: int3) -> int | the volume of the area spanned by the vector |
| volume(v: int4) -> int | the volume of the area spanned by the vector |
| rnd(max: int) -> int | a random value [0..max). |
| rnd(max: int1) -> int1 | a random struct within the range of an input struct. |
| rnd(max: int2) -> int2 | a random struct within the range of an input struct. |
| rnd(max: int3) -> int3 | a random struct within the range of an input struct. |
| rnd(max: int4) -> int4 | a random struct within the range of an input struct. |
| rnd_float() -> float | a random float [0..1) |
| rnd_gaussian() -> float | a random float in a gaussian distribution with mean 0 and stddev 1 |
| rnd_seed(seed: int) | explicitly set a random seed for reproducable randomness |
| rnd_select(index: int) -> int | select a different random number generator to be active. default is 0, max is 1000000. returns previous value. |
| rndm(max: int) -> int | deprecated: old mersenne twister version of the above for backwards compat. |
| rndm_seed(seed: int) | deprecated: old mersenne twister version of the above for backwards compat. |
| div(a: int, b: int) -> float | forces two ints to be divided as floats |
| clamp(x: int, min: int, max: int) -> int | forces an integer to be in the range between min and max (inclusive) |
| clamp(x: float, min: float, max: float) -> float | forces a float to be in the range between min and max (inclusive) |
| clamp(x: int1, min: int1, max: int1) -> int1 | forces an integer struct to be in the range between min and max (inclusive) |
| clamp(x: int2, min: int2, max: int2) -> int2 | forces an integer struct to be in the range between min and max (inclusive) |
| clamp(x: int3, min: int3, max: int3) -> int3 | forces an integer struct to be in the range between min and max (inclusive) |
| clamp(x: int4, min: int4, max: int4) -> int4 | forces an integer struct to be in the range between min and max (inclusive) |
| clamp(x: float1, min: float1, max: float1) -> float1 | forces a float struct to be in the range between min and max (inclusive) |
| clamp(x: float2, min: float2, max: float2) -> float2 | forces a float struct to be in the range between min and max (inclusive) |
| clamp(x: float3, min: float3, max: float3) -> float3 | forces a float struct to be in the range between min and max (inclusive) |
| clamp(x: float4, min: float4, max: float4) -> float4 | forces a float struct to be in the range between min and max (inclusive) |
| in_range(x: int, range: int, bias: int = 0) -> int | checks if an integer is >= bias and < bias + range. Bias defaults to 0. |
| in_range(x: float, range: float, bias: float = 0.000000) -> int | checks if a float is >= bias and < bias + range. Bias defaults to 0. |
| in_range(x: int2, range: int2, bias: int2 = nil) -> int | checks if a 2d integer vector is >= bias and < bias + range. Bias defaults to 0. |
| in_range(x: int3, range: int3, bias: int3 = nil) -> int | checks if a 3d integer vector is >= bias and < bias + range. Bias defaults to 0. |
| in_range(x: float2, range: float2, bias: float2 = nil) -> int | checks if a 2d float vector is >= bias and < bias + range. Bias defaults to 0. |
| in_range(x: float3, range: float3, bias: float3 = nil) -> int | checks if a 3d float vector is >= bias and < bias + range. Bias defaults to 0. |
| abs(x: int) -> int | absolute value of an integer |
| abs(x: float) -> float | absolute value of a float |
| abs(x: int1) -> int1 | absolute value of an int vector |
| abs(x: int2) -> int2 | absolute value of an int vector |
| abs(x: int3) -> int3 | absolute value of an int vector |
| abs(x: int4) -> int4 | absolute value of an int vector |
| abs(x: float1) -> float1 | absolute value of a float vector |
| abs(x: float2) -> float2 | absolute value of a float vector |
| abs(x: float3) -> float3 | absolute value of a float vector |
| abs(x: float4) -> float4 | absolute value of a float vector |
| sign(x: int) -> int | sign (-1, 0, 1) of an integer |
| sign(x: float) -> int | sign (-1, 0, 1) of a float |
| sign(x: int1) -> int1 | signs of an int vector |
| sign(x: int2) -> int2 | signs of an int vector |
| sign(x: int3) -> int3 | signs of an int vector |
| sign(x: int4) -> int4 | signs of an int vector |
| sign(x: float1) -> int1 | signs of a float vector |
| sign(x: float2) -> int2 | signs of a float vector |
| sign(x: float3) -> int3 | signs of a float vector |
| sign(x: float4) -> int4 | signs of a float vector |
| min(x: int, y: int) -> int | smallest of 2 integers. |
| min(x: float, y: float) -> float | smallest of 2 floats. |
| min(x: int1, y: int1) -> int1 | smallest components of 2 int vectors |
| min(x: int2, y: int2) -> int2 | smallest components of 2 int vectors |
| min(x: int3, y: int3) -> int3 | smallest components of 2 int vectors |
| min(x: int4, y: int4) -> int4 | smallest components of 2 int vectors |
| min(x: float1, y: float1) -> float1 | smallest components of 2 float vectors |
| min(x: float2, y: float2) -> float2 | smallest components of 2 float vectors |
| min(x: float3, y: float3) -> float3 | smallest components of 2 float vectors |
| min(x: float4, y: float4) -> float4 | smallest components of 2 float vectors |
| min(v: int1) -> int | smallest component of a int vector. |
| min(v: int2) -> int | smallest component of a int vector. |
| min(v: int3) -> int | smallest component of a int vector. |
| min(v: int4) -> int | smallest component of a int vector. |
| min(v: float1) -> float | smallest component of a float vector. |
| min(v: float2) -> float | smallest component of a float vector. |
| min(v: float3) -> float | smallest component of a float vector. |
| min(v: float4) -> float | smallest component of a float vector. |
| min(v: [int]) -> int | smallest component of a int vector, or INT64_MAX if length 0. |
| min(v: [float]) -> float | smallest component of a float vector, or DBL_MAX if length 0. |
| max(x: int, y: int) -> int | largest of 2 integers. |
| max(x: float, y: float) -> float | largest of 2 floats. |
| max(x: int1, y: int1) -> int1 | largest components of 2 int vectors |
| max(x: int2, y: int2) -> int2 | largest components of 2 int vectors |
| max(x: int3, y: int3) -> int3 | largest components of 2 int vectors |
| max(x: int4, y: int4) -> int4 | largest components of 2 int vectors |
| max(x: float1, y: float1) -> float1 | largest components of 2 float vectors |
| max(x: float2, y: float2) -> float2 | largest components of 2 float vectors |
| max(x: float3, y: float3) -> float3 | largest components of 2 float vectors |
| max(x: float4, y: float4) -> float4 | largest components of 2 float vectors |
| max(v: int1) -> int | largest component of a int vector. |
| max(v: int2) -> int | largest component of a int vector. |
| max(v: int3) -> int | largest component of a int vector. |
| max(v: int4) -> int | largest component of a int vector. |
| max(v: float1) -> float | largest component of a float vector. |
| max(v: float2) -> float | largest component of a float vector. |
| max(v: float3) -> float | largest component of a float vector. |
| max(v: float4) -> float | largest component of a float vector. |
| max(v: [int]) -> int | largest component of a int vector, or INT64_MIN if length 0. |
| max(v: [float]) -> float | largest component of a float vector, or -DBL_MAX if length 0. |
| popcount(x: int) -> int | number of bits set in an integer |
| lerp(x: float, y: float, f: float) -> float | linearly interpolates between x and y with factor f [0..1] |
| lerp(a: float2, b: float2, f: float) -> float2 | linearly interpolates between a and b vectors with factor f [0..1] |
| lerp(a: float3, b: float3, f: float) -> float3 | linearly interpolates between a and b vectors with factor f [0..1] |
| lerp(a: float4, b: float4, f: float) -> float4 | linearly interpolates between a and b vectors with factor f [0..1] |
| spherical_lerp(a: float4, b: float4, f: float) -> float4 | spherically interpolates between a and b quaternions with factor f [0..1] |
| smoothmin(x: float, y: float, k: float) -> float | k is the influence range |
| smoothstep(x: float) -> float | input must be in range 0..1, https://en.wikipedia.org/wiki/Smoothstep |
| smoothstep(a: float, b: float, f: float) -> float | hermite interpolation between a and b by f [0..1], https://registry.khronos.org/OpenGL-Refpages/gl4/html/smoothstep.xhtml |
| smootherstep(x: float) -> float | input must be in range 0..1, https://en.wikipedia.org/wiki/Smoothstep |
| cardinal_spline(z: float2, a: float2, b: float2, c: float2, f: float, tension: float) -> float2 | computes the position between a and b with factor f [0..1], using z (before a) and c (after b) to form a cardinal spline (tension at 0.5 is a good default) |
| cardinal_spline(z: float3, a: float3, b: float3, c: float3, f: float, tension: float) -> float3 | computes the position between a and b with factor f [0..1], using z (before a) and c (after b) to form a cardinal spline (tension at 0.5 is a good default) |
| line_intersect(line1a: float2, line1b: float2, line2a: float2, line2b: float2) -> int, float2 | computes if there is an intersection point between 2 line segments, with the point as second return value |
| circles_within_range(dist: float, positions: [float2], radiuses: [float], positions2: [float2], radiuses2: [float], gridsize: int2) -> [[int]] | Given a vector of 2D positions (and same size vectors of radiuses), returns a vector of vectors of indices (to the second set of positions and radiuses) of the circles that are within dist of eachothers radius. If the second set are [], the first set is used for both (and the self element is excluded). gridsize optionally specifies the size of the grid to use for accellerated lookup of nearby points. This is essential for the algorithm to be fast, too big or too small can cause slowdown. Omit it, and a heuristic will be chosen for you, which is currently sqrt(num_circles) * 2 along each dimension, e.g. 100 elements would use a 20x20 grid. Efficiency wise this algorithm is fastest if there is not too much variance in the radiuses of the second set and/or the second set has smaller radiuses than the first. |
| wave_function_collapse(tilemap: [string], size: int2) -> [string], int | returns a tilemap of given size modelled after the possible shapes in the input tilemap. Tilemap should consist of chars in the 0..127 range. Second return value the number of failed neighbor matches, this should ideally be 0, but can be non-0 for larger maps. Simply call this function repeatedly until it is 0 |
| hash(x: int) -> int | hashes an int value into a positive int; may be the identity function |
| hash(x: any) -> int | hashes any ref value into a positive int |
| hash(x: function) -> int | hashes a function value into a positive int |
| hash(x: float) -> int | hashes a float value into a positive int |
| hash(v: int1) -> int | hashes a numeric struct into a positive int |
| hash(v: int2) -> int | hashes a numeric struct into a positive int |
| hash(v: int3) -> int | hashes a numeric struct into a positive int |
| hash(v: int4) -> int | hashes a numeric struct into a positive int |
| hash(v: float1) -> int | hashes a numeric struct into a positive int |
| hash(v: float2) -> int | hashes a numeric struct into a positive int |
| hash(v: float3) -> int | hashes a numeric struct into a positive int |
| hash(v: float4) -> int | hashes a numeric struct into a positive int |
| call_function_value(x: function) | calls a void / no args function value.. you shouldn't need to use this, it is a demonstration of how native code can call back into Lobster |
| type_id(ref: any) -> int | int uniquely representing the type of the given reference (object/vector/string/resource). this is the same as typeof, except dynamic (accounts for subtypes of the static type). useful to compare the types of objects quickly. specializations of a generic type will result in different ids. |
| type_string(ref: any) -> string | string representing the type of the given reference (object/vector/string/resource) |
| type_element_string(v: [any]) -> string | string representing the type of the elements of a vector |
| type_field_count(obj: any) -> int | number of fields in an object, or 0 for other reference types |
| type_field_string(obj: any, idx: int) -> string | string representing the type of a field in an object, or empty for other reference types |
| type_field_name(obj: any, idx: int) -> string | name of a field in an object, or empty for other reference types |
| type_field_value(obj: any, idx: int) -> string | string representing the value of a field in an object, or empty for other reference types |
| type_enum_value_name(enum_type_id: typeid(any), idx: int) -> string | string representing the name of an enum value, belonging to the enum (use typeof) |
| type_enum_value_valid(enum_type_id: typeid(any), idx: int) -> int | whether an integer is a value of the given enum (use typeof), i.e. whether type_enum_value_name would give it a name, but without allocating a string. Cheap enough to range check a value that may come from elsewhere (such as a file written by a newer version of the program) before switching on it. For an enum_flags, any combination of declared bits is a value, so this is true for more values than a switch on it has cases |
| program_name() -> string | returns the name of the main program (e.g. "foo.lobster"), "" if running from lpak. |
| vm_compiled_mode() -> int | returns if the VM is running in compiled mode (Lobster -> C++), or false for JIT. |
| seconds_elapsed() -> float | seconds since program start as a float, unlike gl.time() it is calculated every time it is called |
| date_time(utc: bool = false) -> [int] | a vector of integers representing date & time information (index with date_time.lobster). By default returns local time, pass true for UTC instead. |
| date_time_string(utc: bool = false) -> string | a string representing date & time information in the format: 'Www Mmm dd hh:mm:ss yyyy'. By default returns local time, pass true for UTC instead. |
| date_time_string_format(format: string, utc: bool = false) -> string | a string representing date & time information using a formatting string according to https://en.cppreference.com/w/cpp/chrono/c/strftime, for example "%Y_%m_%d_%H_%M_%S". By default returns local time, pass true for UTC instead. |
| date_time_build_info() -> string | a string representing information from when this program was compiled. |
| get_stack_trace() -> string | gets a stack trace of the current location of the program (needs --runtime-stack-trace) without actually stopping the program. |
| get_memory_usage(n: int) -> string | gets a text showing the top n object types that are using the most memory. |
| pass() | does nothing. useful for empty bodies of control structures. |
| reference_count(val: any) -> int | get the reference count of any value. for compiler debugging, mostly |
| set_console(on: bool) | lets you turn on/off the console window (on Windows) |
| set_output_level(level: int) | 0 = debug, 1 = verbose, 2 = warn (default), 3 = error, 4 = program |
| set_exit_code(code: int) | this will be returned when run as a console application |
| command_line_arguments() -> [string] | |
| thread_information() -> int, int | returns the number of hardware threads, and the number of cores |
| is_worker_thread() -> int | whether the current thread is a worker thread |
| start_worker_threads(numthreads: int) | launch worker threads |
| stop_worker_threads() | only needs to be called if you want to stop the worker threads before the end of the program, or if you want to call start_worker_threads again. workers_alive will become false inside the workers, which should then exit. |
| workers_alive() -> int | whether workers should continue doing work. returns false after stop_worker_threads() has been called. |
| thread_write(object: any) | put this object in the thread queue |
| thread_read(type: typeid(any)) -> any? | get an object from the thread queue. pass the typeof object. blocks if no such objects available. returns object, or nil if this was the result of thread_wake() or stop_worker_threads() was called |
| thread_check(type: typeid(any)) -> any? | tests if an object is available on the thread queue. pass the typeof object. returns object, or nil if none available, or if stop_worker_threads() was called |
| thread_wake(type: typeid(any)) | wakes up one thread that are currently blocked on a thread_read for this type. this will cause them to return nil since no object is sent. it is similar to thread_write(nil) |
| crash_test_cpp_nullptr_exception() | only for testing crash dump functionality, don't use! :) |
| profiler_dump_stats(num: int, histogram: bool) -> string | returns a string with CSV data for the num top items |
| profiler_paused(paused: bool) | |
| profiler_reset() | |