| ( *~ ) [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] |