Index of values

( *~ ) [Value]

-val ( *~ ) : value -> value -> value, operator of v_mul. -

(+~) [Value]

-val (+~) : value -> value -> value, operator of v_add. -

(-~) [Value]

-val (-~) : value -> value -> value, operator of v_sub. -

(/~) [Value]

-val (/~) : value -> value -> value, operator of v_div. -

__ocaml_lex_tables [Lexer]

__ocaml_lex_token_rec [Lexer]

arrange [Interpreter]

-val arrange : 'a array array array -> int -> 'a array list, -arranges the output data in "array list" form. -

beam_add_one_memory [Signal]

-val beam_add_one_memory : signal list -> signal list, -adds memory of one latest sample for each element in signal list. -

channels [Interpreter]

-val channels : 'a array array array -> int -> int array, -returns an array of number of channels. -

check_frequency [Signal]

-val check_frequency : int -> int -> int, returns the correction of frequency. -

compute [Interpreter]

-val compute : (int -> value) list -> (int list) * (float array list). -

computing [Interpreter]

-val computing : (int -> value array) -> int -> int -> float array array array, -applies time sequence "0,1,2,3,...,max" to signal beam, -returns primitive output data. -

convert_back_R [Value]

-val convert_back_r : value -> float array, -return a float array of size 1 if v is N|R|Zero|W, a float array of size n if v is Vec. -

d_merge [Faustexp]

-val d_merge : int * int -> int * int -> int * int, process dimension for constructor "merge(:>)", -which is (size of input beam of first exp, size of output beam of second exp) -along with beam matching. -

d_par [Faustexp]

-val d_par : int * int -> int * int -> int * int, process dimension for constructor "par(,)", -which is the addition of two dimensions. -

d_rec [Faustexp]

-val d_rec : int * int -> int * int -> int * int, process dimension for constructor "rec(~)", -which is (size of input beam of first exp - size of output beam of second exp, -size of output beam of first exp) -along with beam matching. -

d_seq [Faustexp]

-val d_seq : int * int -> int * int -> int * int, process dimension for constructor "seq(:)", -which is (size of input beam of first exp, size of output beam of second exp) -along with beam matching. -

d_split [Faustexp]

-val d_split : int * int -> int * int -> int * int, process dimension for constructor "split(<:)", -which is (size of input beam of first exp, size of output beam of second exp) -along with beam matching. -

delay [Faustexp]

-val delay : faust_exp -> int, returns the number of delays estimated staticly. -

dim [Faustexp]

-val dim : faust_exp -> int * int, returns dimension for faust expression, -along with beam matching. -

eval [Interpreter]

-val rec eval : faust_exp -> beam -> beam, -main interpretation work is done here. -

exp_of_string [Faustexp]

-val exp_of_string : string -> faust_exp, faust expression parser. -

extract_rate [Interpreter]

-val extract_rate : (int * (int -> value)) list -> int list, -gets the sample rate list from beam. -

factory_add_memory [Value]

-val factory_add_memory : (int -> 'b) -> int -> (int -> 'b), -factory_add_memory f n adds a memory of size n to fun f. -

fail [Value]

-val fail, return value W. -

frequency [Signal]

-val frequency : signal -> int, returns the frequency of a signal. -

fun_array_to_fun [Interpreter]

-val func_of_func_array : (int -> value) array -> (int -> value array), -applies the same int parameter to each element of function array, -produces a value array. -

get_root [Faustexp]

-val get_root : dimension -> int * int, returns the root of dimension tree. -

interpret_const [Interpreter]

-val interpret_const : value -> beam -> beam, generates constant signal with frequency 0. -

interpret_ident [Interpreter]

-val interpret_ident : string -> beam -> beam, -generates signals according to identified symbols. -

interpreter [Interpreter]

-val interpreter : faust_exp -> (int list) * (float array list) -> -(int list) * (int list) * (float array list) -input: faust expression, sample rate list * input data list -output: channel list * sample rate list * output data list. -

interpreter_macro_to_value [Interpreter]

-val interpreter_macro_to_value : returns the value associated with the macro. -

io_macro_to_string [Main]

-val io_macro_to_string : io_macro -> string. -

main [Main]

main [Parser]

make_beam [Interpreter]

-val make_beam : (int list) * (float array list) -> (int * (int -> value)) list, -input: (sample rate list, data list) -output: beam = (sample rate, function) list -

make_vector [Value]

-val make_vector : int -> (int -> value) -> value, -make_vector size vec, return a value Vec of (size, vec). -

matrix_transpose [Interpreter]

-val matrix_transpose : 'a array array -> 'a array array, -transposes the input matrix. -

normalize [Value]

-val normalize: value -> value, normalize value to bounded -2147483648,2147483647. -

preprocess [Preprocess]

print_exp [Faustexp]

-val print_exp : faust_exp -> unit, print to console the input faust expression. -

print_value_list [Value]

-val print_value_list: value list -> unit, prints to console the value list. -

read_input_wave [Main]

-val read_input_wave : string array -> int list * float array list - read_input_wave argv gets information from command line, - returns sample rate list and data (in form of float array) list. -

return_N [Value]

-val return_N : int -> value, convert from int to value N. -

return_R [Value]

-val return_R : float -> value, convert from float to value R. -

return_Vec [Value]

-val return_Vec : int * (int -> value) -> value, convert (size, vec) to value Vec. -

set_GC [Main]

-val set_GC : unit -> unit -

signal_add [Signal]

-val signal_add : signal -> signal -> signal, output(t) = input1(t) + input2(t), - frequency consistent. -

signal_add_one_memory [Signal]

-val signal_add_one_memory : signal -> signal, -returns the signal with memory of one latest sample. -

signal_append [Signal]

-val signal_append : signal -> signal -> signal, symbol "#", - appends vectors of the two input signals at each time, frequency consistent. -

signal_atan [Signal]

-val signal_atan : signal -> signal, output(t) = v_atan(input(t)), frequency consistent. -

signal_atantwo [Signal]

signal_check_frequency [Signal]

-val signal_check_frequency : signal -> signal -> int, -checks the frequencies of two input signals, and returns common frequency or raise an exception. -

signal_check_frequency3 [Signal]

-val signal_check_frequency3 : signal -> signal -> signal -> int, -checks the frequencies of three input signal, and returns common frequency or raise an exception. -

signal_check_frequency4 [Signal]

-val signal_check_frequency4 : signal -> signal -> signal -> signal -> int, -checks the frequencies of three input signal, and returns common frequency or raise an exception. -

signal_cos [Signal]

-val signal_cos : signal -> signal, output(t) = v_cos(input(t)), frequency consistent. -

signal_delay [Signal]

-val signal_delay : signal -> signal -> signal, output(t) = input1(t - input2(t)), - Attention: delay dynamic, frequency of output signal equals to that of first input signal. -

signal_div [Signal]

-val signal_div : signal -> signal -> signal, output(t) = input1(t) / input2(t), - frequency consistent. -

signal_floor [Signal]

-val signal_floor : signal -> signal, output(t) = v_floor(input(t)), frequency consistent. -

signal_fun [Signal]

-val signal_fun : signal -> (int -> value), returns the functional part of a signal. -

signal_inf [Signal]

-val signal_inf : signal -> signal -> signal, - output(t) = input1(t) < input2(t), frequency consistent. -

signal_int [Signal]

-val signal_int : signal -> signal, output(t) = v_int(input(t)), frequency consistent. -

signal_macro_to_int [Signal]

-val signal_macro_to_int : signal_macro -> int. -

signal_mem [Signal]

-val signal_mem : signal -> signal, equivalent to signal_delay with constant delay 1. -

signal_mod [Signal]

-val signal_mod : signal -> signal -> signal, - output(t) = input1(t) % input2(t), frequency consistent. -

signal_mul [Signal]

-val signal_mul : signal -> signal -> signal, output(t) = input1(t) * input2(t), - frequency consistent. -

signal_neg [Signal]

-val signal_neg : signal -> signal, output(t) = -input(t), frequency consistent. -

signal_nth [Signal]

-val signal_nth : signal -> signal -> signal, symbol "[]", output(t) = input1(t)(input2(t)), - frequency consistent. -

signal_prefix [Signal]

-val signal_prefix : signal -> signal -> signal, -signal_prefix s0 s1 returns s0(0) if t = 0, s1(t-1) if t > 0, frequency same to s1. -

signal_rdtable [Signal]

-val signal_rdtable : signal -> signal -> signal, - output(t) = input1(input2(t)), frequency equals to that of input2. -

signal_select2 [Signal]

-val signal_select2 : signal -> signal -> signal -> signal, -signal_select2 si s0 s1 selects s0 or s1 by index si, frequency consistent. -

signal_select3 [Signal]

-val signal_select3 : signal -> signal -> signal -> signal -> signal, -signal_select3 si s0 s1 s2 selects s0 or s1 or s2 by index si, frequency consistent. -

signal_serialize [Signal]

-val signal_serialize : signal -> signal, output(t) = input(floor(t/n))(t%n), - with n = size of input(0). -

signal_sin [Signal]

-val signal_sin : signal -> signal, output(t) = v_sin(input(t)), frequency consistent. -

signal_sqrt [Signal]

-val signal_sqrt : signal -> signal, output(t) = v_sqrt(input(t)), frequency consistent. -

signal_sub [Signal]

-val signal_sub : signal -> signal -> signal, output(t) = input1(t) - input2(t), - frequency consistent. -

signal_sup [Signal]

-val signal_sup : signal -> signal -> signal, - output(t) = input1(t) > input2(t), frequency consistent. -

signal_vectorize [Signal]

-val signal_vectorize : signal -> signal -> signal, output(t)(i) = input1(input2(0) * t + i), -Attention: vector size n static, frequency of output signal is (1/n * frequency of input1) -

string_of_value [Value]

-val string_of_value : value -> string, converts value to following -strings "N i" | "R f" | "Vec" | "Zero" | "W". -

sublist [Interpreter]

-val sublist : 'a list -> int -> int -> 'a list, -sublist l start length, returns the sublist of list 'l', -from index 'start', with length 'length'. -

subtree [Faustexp]

-val subtree : dimention -> int -> dimension, returns a subtree of dimension tree. -

subtree_left [Faustexp]

-val subtree_left : dimension -> dimension, returns the left subtree of dimension tree. -

subtree_right [Faustexp]

-val subtree_right : dimension -> dimension, returns the right subtree of dimension tree. -

symbol_of_string [Types]

take_off_N [Value]

-val take_off_N : value -> int, convert from value N to int. -

take_off_R [Value]

-val take_off_R : value -> float, convert from value R to float. -

token [Lexer]

v_add [Value]

-val v_add : value -> value -> value, value addition, recursive for value.Vec. -

v_atan [Value]

-val v_atan : value -> value, returns atan(v), recursive for value.Vec. -

v_atantwo [Value]

-val v_atantwo : value -> value, returns atantwo(v), recursive for value.Vec. -

v_cos [Value]

-val v_cos : value -> value, returns cos(v), recursive for value.Vec. -

v_div [Value]

-val v_div : value -> value -> value, value division, returns (v1/.v2). -

v_floor [Value]

-val v_floor : value -> value, returns floor of float, converts int to float, Zero to 0., - error to error, recursive for value.Vec. -

v_inf [Value]

-val v_inf : value -> value -> value, comparison of two values, returns value.N 1 if (v1 < v2), -value.N 0 else. -

v_int [Value]

-val v_int : value -> value, converts value to value.N, error to error, recursive for value.Vec. -

v_larger_than_zero [Value]

-val v_larger_than_zero : value -> value, primitive comparison between value and zero, -returns value.N 1 if true, value.N 0 if false. -

v_list_memory [Value]

-val v_list_memory : value list -> value list, returns value list with memory. -

v_memory [Value]

-val v_memory : value -> value, returns value Vec with memory. -

v_mod [Value]

-val v_mod : value -> value -> value, returns (v1 % v2), recursive for value.Vec. -

v_mul [Value]

-val v_mul : value -> value -> value, returns (v1 * v2), recursive for value.Vec. -

v_neg [Value]

-val v_neg : value -> value, v_neg v = -v. -

v_recip [Value]

-val v_recip : value -> value, v_recip v = 1./.v. -

v_sin [Value]

-val v_sin : value -> value, returns sin(v), recursive for value.Vec. -

v_sqrt [Value]

-val v_sqrt : value -> value, returns sqrt(v), recursive for value.Vec. -

v_sub [Value]

-val v_sub : value -> value -> value, returns (v1 - v2). -

v_sup [Value]

-val v_sup : value -> value -> value, comparison of two values, returns value.N 1 if (v1 > v2), -value.N 0 else. -

v_zero [Value]

-val v_zero : value -> value, Attention: N i -> N 0 | R f -> R 0. -

value_macro_to_int [Value]

-val value_macro_to_value : value_macro -> int. -

write_output_txt [Main]

write_output_wave [Main]

-val write_output_wave : int list -> int list -> float_array_list -> unit. -

yyact [Parser]

yylen [Parser]

yylhs [Parser]

yynames_block [Parser]

yynames_const [Parser]

yytransl_block [Parser]

yytransl_const [Parser]