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]

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

B
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.

C
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
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.

E
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.

F
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.

G
get_root [Faustexp]
val get_root : dimension -> int * int, returns the root of dimension tree.

I
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.

M
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.

N
normalize [Value]
val normalize: value -> value, normalize value to bounded -2147483648,2147483647.

P
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.

R
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.

S
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]

T
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
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.

W
write_output_txt [Main]
write_output_wave [Main]
val write_output_wave : int list -> int list -> float_array_list -> unit.

Y
yyact [Parser]
yycheck [Parser]
yydefred [Parser]
yydgoto [Parser]
yygindex [Parser]
yylen [Parser]
yylhs [Parser]
yynames_block [Parser]
yynames_const [Parser]
yyrindex [Parser]
yysindex [Parser]
yytable [Parser]
yytables [Parser]
yytablesize [Parser]
yytransl_block [Parser]
yytransl_const [Parser]