bifs

package
v6.13.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 5, 2024 License: BSD-2-Clause Imports: 22 Imported by: 0

Documentation

Index

Constants

View Source
const ISO8601_TIME_FORMAT = "%Y-%m-%dT%H:%M:%SZ"

Variables

This section is empty.

Functions

func BIF_abs

func BIF_abs(input1 *mlrval.Mlrval) *mlrval.Mlrval

Int-preserving

func BIF_acos

func BIF_acos(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_acosh

func BIF_acosh(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_antimode

func BIF_antimode(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_append

func BIF_append(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_arrayify

func BIF_arrayify(input1 *mlrval.Mlrval) *mlrval.Mlrval

---------------------------------------------------------------- Converts maps with "1", "2", ... keys into arrays. Recurses nested data structures.

func BIF_asin

func BIF_asin(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_asinh

func BIF_asinh(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_asserting_absent

func BIF_asserting_absent(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_array

func BIF_asserting_array(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_bool

func BIF_asserting_bool(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_boolean

func BIF_asserting_boolean(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_empty

func BIF_asserting_empty(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_emptyMap

func BIF_asserting_emptyMap(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_error

func BIF_asserting_error(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_float

func BIF_asserting_float(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_int

func BIF_asserting_int(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_map

func BIF_asserting_map(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_nonempty_map

func BIF_asserting_nonempty_map(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_not_array

func BIF_asserting_not_array(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_not_empty

func BIF_asserting_not_empty(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_not_map

func BIF_asserting_not_map(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_not_null

func BIF_asserting_not_null(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_null

func BIF_asserting_null(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_numeric

func BIF_asserting_numeric(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_present

func BIF_asserting_present(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_asserting_string

func BIF_asserting_string(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

func BIF_atan

func BIF_atan(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_atan2

func BIF_atan2(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_atanh

func BIF_atanh(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_bitcount

func BIF_bitcount(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_bitwise_and

func BIF_bitwise_and(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_bitwise_not

func BIF_bitwise_not(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_bitwise_or

func BIF_bitwise_or(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_bitwise_xor

func BIF_bitwise_xor(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_boolean

func BIF_boolean(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_capitalize

func BIF_capitalize(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_cbrt

func BIF_cbrt(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_ceil

func BIF_ceil(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_clean_whitespace

func BIF_clean_whitespace(input1 *mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_cmp

func BIF_cmp(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_collapse_whitespace

func BIF_collapse_whitespace(input1 *mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_collapse_whitespace_regexp

func BIF_collapse_whitespace_regexp(input1 *mlrval.Mlrval, whitespaceRegexp *regexp.Regexp) *mlrval.Mlrval

func BIF_concat

func BIF_concat(mlrvals []*mlrval.Mlrval) *mlrval.Mlrval

================================================================

func BIF_contains

func BIF_contains(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_cos

func BIF_cos(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_cosh

func BIF_cosh(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_count

func BIF_count(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_depth

func BIF_depth(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_dhms2fsec

func BIF_dhms2fsec(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_dhms2sec

func BIF_dhms2sec(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_distinct_count

func BIF_distinct_count(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_divide

func BIF_divide(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_dot

func BIF_dot(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_dot_divide

func BIF_dot_divide(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_dot_int_divide

func BIF_dot_int_divide(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_dot_minus

func BIF_dot_minus(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_dot_plus

func BIF_dot_plus(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_dot_times

func BIF_dot_times(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_equals

func BIF_equals(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_erf

func BIF_erf(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_erfc

func BIF_erfc(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_exec

func BIF_exec(mlrvals []*mlrval.Mlrval) *mlrval.Mlrval

func BIF_exp

func BIF_exp(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_expm1

func BIF_expm1(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_finalize_kurtosis

func BIF_finalize_kurtosis(mn, msum, msum2, msum3, msum4 *mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_finalize_mean_eb

func BIF_finalize_mean_eb(mn, msum, msum2 *mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_finalize_skewness

func BIF_finalize_skewness(mn, msum, msum2, msum3 *mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_finalize_stddev

func BIF_finalize_stddev(mn, msum, msum2 *mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_finalize_variance

func BIF_finalize_variance(mn, msum, msum2 *mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_flatten

func BIF_flatten(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

---------------------------------------------------------------- First argument is prefix. Second argument is delimiter. Third argument is map or array. flatten("a", ".", {"b": { "c": 4 }}) is {"a.b.c" : 4}. flatten("", ".", {"a": { "b": 3 }}) is {"a.b" : 3}.

func BIF_flatten_binary

func BIF_flatten_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

flatten($*, ".") is the same as flatten("", ".", $*)

func BIF_float

func BIF_float(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_floor

func BIF_floor(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_fmtifnum

func BIF_fmtifnum(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_fmtnum

func BIF_fmtnum(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_format

func BIF_format(mlrvals []*mlrval.Mlrval) *mlrval.Mlrval

================================================================

func BIF_fsec2dhms

func BIF_fsec2dhms(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_fsec2hms

func BIF_fsec2hms(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_get_keys

func BIF_get_keys(input1 *mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_get_values

func BIF_get_values(input1 *mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_gmt2localtime_binary

func BIF_gmt2localtime_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_gmt2localtime_unary

func BIF_gmt2localtime_unary(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_gmt2nsec

func BIF_gmt2nsec(input1 *mlrval.Mlrval) *mlrval.Mlrval

Argument 1 is formatted date string like "2021-03-04T02:59:50Z".

func BIF_gmt2sec

func BIF_gmt2sec(input1 *mlrval.Mlrval) *mlrval.Mlrval

Argument 1 is formatted date string like "2021-03-04T02:59:50Z".

func BIF_greater_than

func BIF_greater_than(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_greater_than_or_equals

func BIF_greater_than_or_equals(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_gssub

func BIF_gssub(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

BIF_gssub implements the gssub function -- no-frills string-replace, no regexes, no escape sequences.

func BIF_gsub

func BIF_gsub(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

BIF_gsub implements the gsub function, with support for regexes and regex captures of the form "\1" .. "\9".

func BIF_haskey

func BIF_haskey(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_hexfmt

func BIF_hexfmt(input1 *mlrval.Mlrval) *mlrval.Mlrval

================================================================

func BIF_hms2fsec

func BIF_hms2fsec(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_hms2sec

func BIF_hms2sec(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_hostname

func BIF_hostname() *mlrval.Mlrval

func BIF_index

func BIF_index(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_int

func BIF_int(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_int_divide

func BIF_int_divide(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_int_with_base

func BIF_int_with_base(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_invqnorm

func BIF_invqnorm(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_absent

func BIF_is_absent(input1 *mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_is_array

func BIF_is_array(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_bool

func BIF_is_bool(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_boolean

func BIF_is_boolean(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_empty

func BIF_is_empty(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_emptymap

func BIF_is_emptymap(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_error

func BIF_is_error(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_float

func BIF_is_float(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_int

func BIF_is_int(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_map

func BIF_is_map(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_nan

func BIF_is_nan(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_nonemptymap

func BIF_is_nonemptymap(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_notarray

func BIF_is_notarray(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_notempty

func BIF_is_notempty(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_notmap

func BIF_is_notmap(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_notnull

func BIF_is_notnull(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_null

func BIF_is_null(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_numeric

func BIF_is_numeric(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_present

func BIF_is_present(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_is_string

func BIF_is_string(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_joink

func BIF_joink(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

================================================================ joink([1,2,3], ",") -> "1,2,3" joink({"a":3,"b":4,"c":5}, ",") -> "a,b,c"

func BIF_joinkv

func BIF_joinkv(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

---------------------------------------------------------------- joinkv([3,4,5], "=", ",") -> "1=3,2=4,3=5" joinkv({"a":3,"b":4,"c":5}, "=", ",") -> "a=3,b=4,c=5"

func BIF_joinv

func BIF_joinv(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

---------------------------------------------------------------- joinv([3,4,5], ",") -> "3,4,5" joinv({"a":3,"b":4,"c":5}, ",") -> "3,4,5"

func BIF_json_parse

func BIF_json_parse(input1 *mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_json_stringify_binary

func BIF_json_stringify_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_json_stringify_unary

func BIF_json_stringify_unary(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_kurtosis

func BIF_kurtosis(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_latin1_to_utf8

func BIF_latin1_to_utf8(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_leafcount

func BIF_leafcount(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_left_shift

func BIF_left_shift(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_leftpad

func BIF_leftpad(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

================================================================

func BIF_length

func BIF_length(input1 *mlrval.Mlrval) *mlrval.Mlrval

================================================================ Map/array count. Scalars (including strings) have length 1; strlen is for string length.

func BIF_less_than

func BIF_less_than(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_less_than_or_equals

func BIF_less_than_or_equals(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_localtime2gmt_binary

func BIF_localtime2gmt_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_localtime2gmt_unary

func BIF_localtime2gmt_unary(input1 *mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_localtime2nsec_binary

func BIF_localtime2nsec_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_localtime2nsec_unary

func BIF_localtime2nsec_unary(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_localtime2sec_binary

func BIF_localtime2sec_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_localtime2sec_unary

func BIF_localtime2sec_unary(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_log

func BIF_log(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_log10

func BIF_log10(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_log1p

func BIF_log1p(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_logical_AND

func BIF_logical_AND(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_logical_NOT

func BIF_logical_NOT(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_logical_OR

func BIF_logical_OR(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_logical_XOR

func BIF_logical_XOR(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_logifit

func BIF_logifit(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_lstrip

func BIF_lstrip(input1 *mlrval.Mlrval) *mlrval.Mlrval

================================================================

func BIF_mapdiff

func BIF_mapdiff(mlrvals []*mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_mapexcept

func BIF_mapexcept(mlrvals []*mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_mapselect

func BIF_mapselect(mlrvals []*mlrval.Mlrval) *mlrval.Mlrval

================================================================

func BIF_mapsum

func BIF_mapsum(mlrvals []*mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_max_binary

func BIF_max_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

BIF_max_binary is not a direct DSL function. It's a helper here, and is also exposed publicly for use by the stats1 verb.

func BIF_max_variadic

func BIF_max_variadic(mlrvals []*mlrval.Mlrval) *mlrval.Mlrval

func BIF_max_within_map_values

func BIF_max_within_map_values(m *mlrval.Mlrmap) *mlrval.Mlrval

func BIF_maxlen

func BIF_maxlen(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_maxlen_variadic

func BIF_maxlen_variadic(mlrvals []*mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_maxlen_within_map_values

func BIF_maxlen_within_map_values(m *mlrval.Mlrmap) *mlrval.Mlrval

func BIF_md5

func BIF_md5(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_mean

func BIF_mean(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_meaneb

func BIF_meaneb(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_median

func BIF_median(
	collection *mlrval.Mlrval,
) *mlrval.Mlrval

func BIF_median_with_options

func BIF_median_with_options(
	collection *mlrval.Mlrval,
	options *mlrval.Mlrval,
) *mlrval.Mlrval

func BIF_min_binary

func BIF_min_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

BIF_min_binary is not a direct DSL function. It's a helper here, and is also exposed publicly for use by the stats1 verb.

func BIF_min_variadic

func BIF_min_variadic(mlrvals []*mlrval.Mlrval) *mlrval.Mlrval

func BIF_min_within_map_values

func BIF_min_within_map_values(m *mlrval.Mlrmap) *mlrval.Mlrval

func BIF_minlen

func BIF_minlen(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_minlen_variadic

func BIF_minlen_variadic(mlrvals []*mlrval.Mlrval) *mlrval.Mlrval

----------------------------------------------------------------

func BIF_minlen_within_map_values

func BIF_minlen_within_map_values(m *mlrval.Mlrmap) *mlrval.Mlrval

func BIF_minus_binary

func BIF_minus_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_minus_unary

func BIF_minus_unary(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_mod_add

func BIF_mod_add(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_mod_exp

func BIF_mod_exp(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_mod_mul

func BIF_mod_mul(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_mod_sub

func BIF_mod_sub(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_mode

func BIF_mode(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_modulus

func BIF_modulus(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_not_equals

func BIF_not_equals(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_nsec2gmt_binary

func BIF_nsec2gmt_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_nsec2gmt_unary

func BIF_nsec2gmt_unary(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_nsec2gmtdate

func BIF_nsec2gmtdate(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_nsec2localdate_binary

func BIF_nsec2localdate_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_nsec2localdate_unary

func BIF_nsec2localdate_unary(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_nsec2localtime_binary

func BIF_nsec2localtime_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_nsec2localtime_ternary

func BIF_nsec2localtime_ternary(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_nsec2localtime_unary

func BIF_nsec2localtime_unary(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_null_count

func BIF_null_count(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_os

func BIF_os() *mlrval.Mlrval

func BIF_percentile

func BIF_percentile(
	collection *mlrval.Mlrval,
	percentile *mlrval.Mlrval,
) *mlrval.Mlrval

func BIF_percentile_with_options

func BIF_percentile_with_options(
	collection *mlrval.Mlrval,
	percentile *mlrval.Mlrval,
	options *mlrval.Mlrval,
) *mlrval.Mlrval

func BIF_percentiles

func BIF_percentiles(
	collection *mlrval.Mlrval,
	percentiles *mlrval.Mlrval,
) *mlrval.Mlrval

func BIF_percentiles_with_options

func BIF_percentiles_with_options(
	collection *mlrval.Mlrval,
	percentiles *mlrval.Mlrval,
	options *mlrval.Mlrval,
) *mlrval.Mlrval

func BIF_plus_binary

func BIF_plus_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_plus_unary

func BIF_plus_unary(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_pow

func BIF_pow(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_qnorm

func BIF_qnorm(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_regextract

func BIF_regextract(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_regextract_or_else

func BIF_regextract_or_else(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_rightpad

func BIF_rightpad(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_round

func BIF_round(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_roundm

func BIF_roundm(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_rstrip

func BIF_rstrip(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sec2dhms

func BIF_sec2dhms(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sec2gmt_binary

func BIF_sec2gmt_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sec2gmt_unary

func BIF_sec2gmt_unary(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sec2gmtdate

func BIF_sec2gmtdate(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sec2hms

func BIF_sec2hms(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sec2localdate_binary

func BIF_sec2localdate_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sec2localdate_unary

func BIF_sec2localdate_unary(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sec2localtime_binary

func BIF_sec2localtime_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sec2localtime_ternary

func BIF_sec2localtime_ternary(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sec2localtime_unary

func BIF_sec2localtime_unary(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sgn

func BIF_sgn(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sha1

func BIF_sha1(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sha256

func BIF_sha256(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sha512

func BIF_sha512(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_signed_right_shift

func BIF_signed_right_shift(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sin

func BIF_sin(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sinh

func BIF_sinh(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_skewness

func BIF_skewness(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sort_collection

func BIF_sort_collection(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_splita

func BIF_splita(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

---------------------------------------------------------------- splita("3,4,5", ",") -> [3,4,5]

func BIF_splitax

func BIF_splitax(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

---------------------------------------------------------------- BIF_splitax splits a string to an array, without type-inference: e.g. splitax("3,4,5", ",") -> ["3","4","5"]

func BIF_splitkv

func BIF_splitkv(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

================================================================ splitkv("a=3,b=4,c=5", "=", ",") -> {"a":3,"b":4,"c":5}

func BIF_splitkvx

func BIF_splitkvx(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

---------------------------------------------------------------- splitkvx("a=3,b=4,c=5", "=", ",") -> {"a":"3","b":"4","c":"5"}

func BIF_splitnv

func BIF_splitnv(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

---------------------------------------------------------------- splitnv("a,b,c", ",") -> {"1":"a","2":"b","3":"c"}

func BIF_splitnvx

func BIF_splitnvx(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

---------------------------------------------------------------- splitnvx("3,4,5", ",") -> {"1":"3","2":"4","3":"5"}

func BIF_sqrt

func BIF_sqrt(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_ssub

func BIF_ssub(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

BIF_ssub implements the ssub function -- no-frills string-replace, no regexes, no escape sequences.

func BIF_stat

func BIF_stat(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_stddev

func BIF_stddev(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_strfntime

func BIF_strfntime(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_strfntime_local_binary

func BIF_strfntime_local_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_strfntime_local_ternary

func BIF_strfntime_local_ternary(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_strftime

func BIF_strftime(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_strftime_local_binary

func BIF_strftime_local_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_strftime_local_ternary

func BIF_strftime_local_ternary(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_string

func BIF_string(input1 *mlrval.Mlrval) *mlrval.Mlrval

================================================================

func BIF_string_does_not_match_regexp

func BIF_string_does_not_match_regexp(input1, input2 *mlrval.Mlrval) (retval *mlrval.Mlrval, captures []string)

BIF_string_does_not_match_regexp implements the !=~ operator.

func BIF_string_matches_regexp

func BIF_string_matches_regexp(input1, input2 *mlrval.Mlrval) (retval *mlrval.Mlrval, captures []string)

BIF_string_matches_regexp implements the =~ operator, with support for setting regex-captures for later expressions to access using "\1" .. "\9".

func BIF_strip

func BIF_strip(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_strlen

func BIF_strlen(input1 *mlrval.Mlrval) *mlrval.Mlrval

================================================================

func BIF_strmatch

func BIF_strmatch(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_strmatchx

func BIF_strmatchx(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_strpntime

func BIF_strpntime(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_strpntime_local_binary

func BIF_strpntime_local_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_strpntime_local_ternary

func BIF_strpntime_local_ternary(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_strptime

func BIF_strptime(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

================================================================ Argument 1 is formatted date string like "2021-03-04 02:59:50". Argument 2 is format string like "%Y-%m-%d %H:%M:%S".

func BIF_strptime_local_binary

func BIF_strptime_local_binary(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_strptime_local_ternary

func BIF_strptime_local_ternary(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sub

func BIF_sub(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

BIF_sub implements the sub function, with support for regexes and regex captures of the form "\1" .. "\9".

func BIF_substr_0_up

func BIF_substr_0_up(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_substr_1_up

func BIF_substr_1_up(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sum

func BIF_sum(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sum2

func BIF_sum2(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sum3

func BIF_sum3(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sum4

func BIF_sum4(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_sysntime

func BIF_sysntime() *mlrval.Mlrval

func BIF_system

func BIF_system(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_systime

func BIF_systime() *mlrval.Mlrval

================================================================

func BIF_systimeint

func BIF_systimeint() *mlrval.Mlrval

func BIF_tan

func BIF_tan(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_tanh

func BIF_tanh(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_times

func BIF_times(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_tolower

func BIF_tolower(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_toupper

func BIF_toupper(input1 *mlrval.Mlrval) *mlrval.Mlrval

================================================================

func BIF_truncate

func BIF_truncate(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

================================================================

func BIF_typeof

func BIF_typeof(input1 *mlrval.Mlrval) *mlrval.Mlrval

================================================================

func BIF_unflatten

func BIF_unflatten(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

---------------------------------------------------------------- First argument is a map. Second argument is a delimiter string. unflatten({"a.b.c", ".") is {"a": { "b": { "c": 4}}}.

func BIF_unformat

func BIF_unformat(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

unformat("{}:{}:{}", "1:2:3") gives [1, 2] unformat("{}h{}m{}s", "3h47m22s") gives [3, 47, 22]

func BIF_unformatx

func BIF_unformatx(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_unsigned_right_shift

func BIF_unsigned_right_shift(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_upntime

func BIF_upntime() *mlrval.Mlrval

func BIF_uptime

func BIF_uptime() *mlrval.Mlrval

func BIF_urand

func BIF_urand() *mlrval.Mlrval

func BIF_urand32

func BIF_urand32() *mlrval.Mlrval

func BIF_urandelement

func BIF_urandelement(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_urandint

func BIF_urandint(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

TODO: use a disposition matrix

func BIF_urandrange

func BIF_urandrange(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_utf8_to_latin1

func BIF_utf8_to_latin1(input1 *mlrval.Mlrval) *mlrval.Mlrval

func BIF_variance

func BIF_variance(collection *mlrval.Mlrval) *mlrval.Mlrval

func BIF_version

func BIF_version() *mlrval.Mlrval

func GetPercentileLinearlyInterpolated

func GetPercentileLinearlyInterpolated(
	array []*mlrval.Mlrval,
	n int,
	p float64,
) *mlrval.Mlrval

func GetPercentileNonInterpolated

func GetPercentileNonInterpolated(
	array []*mlrval.Mlrval,
	n int,
	p float64,
) *mlrval.Mlrval

func MillerSliceAccess

func MillerSliceAccess(
	lowerIndexMlrval *mlrval.Mlrval,
	upperIndexMlrval *mlrval.Mlrval,
	n int,
	isZeroUp bool,
) (
	sliceIsEmpty bool,
	absentOrError *mlrval.Mlrval,
	lowerZindex int,
	upperZindex int,
)

MillerSliceAccess is code shared by the string-slicer and the array-slicer.

  • Miller indices are 1-up, 1..n where n is the length of the array/string. They are also aliased -n..-1. These are called "mindex" (if int) or "index mlrval" (if mlrval).
  • Go indices are 0-up, with no aliasing. These are called "zindex".
  • The job of this routine is to map a pair of index-mlrval to a pair of zindex, with possible outcomes that the slice access should result in an empty array/string, or Mlrval of type absent, or Mlrval of type error.
  • Callsites include the DSL array-slicer (e.g. [1,2,3,4,5][2:3]), the DSL string-slicer (e.g. "abcde"[2:3]), the substr1 function (e.g. substr1("abcde", 2, 3), and the substr0 function (e.g. substr0("abcde", 1, 2)).
  • The isZeroUp argument is in support of substr0.

Types

type BinaryFunc

type BinaryFunc func(input1, input2 *mlrval.Mlrval) *mlrval.Mlrval

Function-pointer type for binary-operator disposition matrices.

type ComparatorFunc

type ComparatorFunc func(*mlrval.Mlrval, *mlrval.Mlrval) int

Function-pointer type for sorting. Returns < 0 if a < b, 0 if a == b, > 0 if a > b.

type RegexCaptureBinaryFunc

type RegexCaptureBinaryFunc func(input *mlrval.Mlrval, sregex *mlrval.Mlrval) (*mlrval.Mlrval, []string)

Returns nil, or one-up captures array as array slots 1..9 of 10-element array for "\1".."\9".

type TernaryFunc

type TernaryFunc func(input1, input2, input3 *mlrval.Mlrval) *mlrval.Mlrval

Function-pointer type for ternary functions

type UnaryFunc

type UnaryFunc func(input1 *mlrval.Mlrval) *mlrval.Mlrval

Function-pointer type for unary-operator disposition vectors.

type UnaryFuncWithContext

type UnaryFuncWithContext func(input1 *mlrval.Mlrval, context *types.Context) *mlrval.Mlrval

The asserting_{type} need access to the context to say things like 'Assertion ... failed at filename {FILENAME} record number {NR}'.

type VariadicFunc

type VariadicFunc func(inputs []*mlrval.Mlrval) *mlrval.Mlrval

Function-pointer type for variadic functions.

type ZaryFunc

type ZaryFunc func() *mlrval.Mlrval

Function-pointer type for zary functions.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL