+++ /dev/null
-<html><head>
-<link rel="stylesheet" href="style.css" type="text/css">
-<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
-<link rel="Start" href="index.html">
-<link title="Index of types" rel=Appendix href="index_types.html">
-<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
-<link title="Index of values" rel=Appendix href="index_values.html">
-<link title="Index of modules" rel=Appendix href="index_modules.html">
-<link title="Types" rel="Chapter" href="Types.html">
-<link title="Parser" rel="Chapter" href="Parser.html">
-<link title="Lexer" rel="Chapter" href="Lexer.html">
-<link title="Value" rel="Chapter" href="Value.html">
-<link title="Signal" rel="Chapter" href="Signal.html">
-<link title="Faustexp" rel="Chapter" href="Faustexp.html">
-<link title="Interpreter" rel="Chapter" href="Interpreter.html">
-<link title="Preprocess" rel="Chapter" href="Preprocess.html">
-<link title="Main" rel="Chapter" href="Main.html"><title>Interpreter.eval</title>
-</head>
-<body>
-<code class="code"><span class="keyword">let</span> <span class="keyword">rec</span> eval exp_faust dimension_tree input_beam = <br>
-<br>
-<br>
-</code><table><tr><td></td><td><span class="comment">(** val interpret_par : faust_exp -> faust_exp -> beam -> beam,
-interprets par(e1, e2) with input beam, produces output beam.*)</span></td></tr></table><code class="code"><br>
-<span class="keyword">let</span> interpret_par = <span class="keyword">fun</span> e1 <span class="keywordsign">-></span> <span class="keyword">fun</span> e2 <span class="keywordsign">-></span> <span class="keyword">fun</span> dimension_tree <span class="keywordsign">-></span> <span class="keyword">fun</span> input_beam <span class="keywordsign">-></span><br>
-<br>
- <span class="comment">(* dimension information *)</span><br>
- <span class="keyword">let</span> n = <span class="constructor">List</span>.length input_beam <span class="keyword">in</span><br>
- <span class="keyword">let</span> subtree1 = subtree_left dimension_tree <span class="keyword">in</span><br>
- <span class="keyword">let</span> subtree2 = subtree_right dimension_tree <span class="keyword">in</span><br>
- <span class="keyword">let</span> d1 = get_root subtree1 <span class="keyword">in</span><br>
- <span class="keyword">let</span> d2 = get_root subtree2 <span class="keyword">in</span><br>
-<br>
- <span class="keyword">if</span> n = (fst d1) + (fst d2) <span class="keyword">then</span> <br>
- ( <br>
- <span class="comment">(* segmentation of input beam *)</span><br>
- <span class="keyword">let</span> input_beam1 = sublist input_beam 0 (fst d1) <span class="keyword">in</span><br>
- <span class="keyword">let</span> input_beam2 = sublist input_beam (fst d1) (fst d2) <span class="keyword">in</span><br>
-<br>
- <span class="comment">(* evaluate two expressions respectively *)</span><br>
- <span class="keyword">let</span> output_beam1 = eval e1 subtree1 input_beam1 <span class="keyword">in</span><br>
- <span class="keyword">let</span> output_beam2 = eval e2 subtree2 input_beam2 <span class="keyword">in</span><br>
-<br>
- <span class="comment">(* concat two output beams *)</span><br>
- <span class="keyword">if</span> <span class="constructor">List</span>.length output_beam1 = snd d1 <span class="keywordsign">&&</span> <span class="constructor">List</span>.length output_beam2 = snd d2 <br>
- <span class="keyword">then</span> (output_beam1 @ output_beam2) <br>
- <span class="keyword">else</span> raise (<span class="constructor">Evaluation_Error</span> <span class="string">"Par"</span>)<br>
- )<br>
- <span class="keyword">else</span> raise (<span class="constructor">Evaluation_Error</span> <span class="string">"Par"</span>) <span class="keyword">in</span><br>
-<br>
-<br>
-</code><table><tr><td></td><td><span class="comment">(** val interpret_seq : faust_exp -> faust_exp -> beam -> beam,
-interprets seq(e1, e2) with input beam, produces output beam.*)</span></td></tr></table><code class="code"><br>
-<span class="keyword">let</span> interpret_seq = <span class="keyword">fun</span> e1 <span class="keywordsign">-></span> <span class="keyword">fun</span> e2 <span class="keywordsign">-></span> <span class="keyword">fun</span> dimension_tree <span class="keywordsign">-></span> <span class="keyword">fun</span> input_beam <span class="keywordsign">-></span><br>
-<br>
- <span class="comment">(* dimension information *)</span><br>
- <span class="keyword">let</span> n = <span class="constructor">List</span>.length input_beam <span class="keyword">in</span><br>
- <span class="keyword">let</span> subtree1 = subtree_left dimension_tree <span class="keyword">in</span><br>
- <span class="keyword">let</span> subtree2 = subtree_right dimension_tree <span class="keyword">in</span><br>
- <span class="keyword">let</span> d1 = get_root subtree1 <span class="keyword">in</span><br>
- <span class="keyword">let</span> d2 = get_root subtree2 <span class="keyword">in</span><br>
-<br>
-<br>
- <span class="keyword">if</span> n = fst d1 <span class="keyword">then</span><br>
- (<br>
- <span class="comment">(* evaluate the first expression *)</span><br>
- <span class="keyword">let</span> output_beam1 = eval e1 subtree1 input_beam <span class="keyword">in</span><br>
-<br>
- <span class="comment">(* evaluate the second expression *)</span><br>
- <span class="keyword">if</span> <span class="constructor">List</span>.length output_beam1 = fst d2 <br>
- <span class="keyword">then</span> eval e2 subtree2 output_beam1<br>
- <span class="keyword">else</span> raise (<span class="constructor">Evaluation_Error</span> <span class="string">"Seq"</span>)<br>
- )<br>
- <span class="keyword">else</span> raise (<span class="constructor">Evaluation_Error</span> <span class="string">"Seq"</span>) <span class="keyword">in</span><br>
-<br>
-<br>
-</code><table><tr><td></td><td><span class="comment">(** val interpret_split : faust_exp -> faust_exp -> beam -> beam,
-interprets split(e1, e2) with input beam, produces output beam.*)</span></td></tr></table><code class="code"><br>
-<span class="keyword">let</span> interpret_split = <span class="keyword">fun</span> e1 <span class="keywordsign">-></span> <span class="keyword">fun</span> e2 <span class="keywordsign">-></span> <span class="keyword">fun</span> dimension_tree <span class="keywordsign">-></span> <span class="keyword">fun</span> input_beam <span class="keywordsign">-></span><br>
-<br>
- <span class="comment">(* dimension information *)</span><br>
- <span class="keyword">let</span> n = <span class="constructor">List</span>.length input_beam <span class="keyword">in</span><br>
- <span class="keyword">let</span> subtree1 = subtree_left dimension_tree <span class="keyword">in</span><br>
- <span class="keyword">let</span> subtree2 = subtree_right dimension_tree <span class="keyword">in</span><br>
- <span class="keyword">let</span> d1 = get_root subtree1 <span class="keyword">in</span><br>
- <span class="keyword">let</span> d2 = get_root subtree2 <span class="keyword">in</span><br>
-<br>
-<br>
- <span class="keyword">if</span> n = fst d1 <span class="keyword">then</span><br>
- (<br>
- <span class="comment">(* evaluate the first expression *)</span><br>
- <span class="keyword">let</span> output_beam1 = eval e1 subtree1 input_beam <span class="keyword">in</span><br>
-<br>
- <span class="comment">(* beam matching *)</span><br>
- <span class="keyword">let</span> ref_output_beam1 = ref (beam_add_one_memory output_beam1) <span class="keyword">in</span><br>
- <span class="keyword">let</span> input_beam2 = <span class="constructor">List</span>.concat <br>
- (<span class="constructor">Array</span>.to_list (<span class="constructor">Array</span>.make ((fst d2)/(<span class="constructor">List</span>.length output_beam1)) !ref_output_beam1)) <br>
- <span class="keyword">in</span><br>
-<br>
- <span class="comment">(* evaluate the second expression *)</span><br>
- <span class="keyword">if</span> <span class="constructor">List</span>.length input_beam2 = fst d2<br>
- <span class="keyword">then</span> eval e2 subtree2 input_beam2<br>
- <span class="keyword">else</span> raise (<span class="constructor">Evaluation_Error</span> <span class="string">"Split"</span>)<br>
- )<br>
- <span class="keyword">else</span> raise (<span class="constructor">Evaluation_Error</span> <span class="string">"Split"</span>) <span class="keyword">in</span><br>
-<br>
-<br>
-</code><table><tr><td></td><td><span class="comment">(** val interpret_merge : faust_exp -> faust_exp -> beam -> beam,
-interprets merge(e1, e2) with input beam, produces output beam.*)</span></td></tr></table><code class="code"><br>
-<span class="keyword">let</span> interpret_merge = <span class="keyword">fun</span> e1 <span class="keywordsign">-></span> <span class="keyword">fun</span> e2 <span class="keywordsign">-></span> <span class="keyword">fun</span> dimension_tree <span class="keywordsign">-></span> <span class="keyword">fun</span> input_beam <span class="keywordsign">-></span><br>
-<br>
- <span class="comment">(* dimension information *)</span><br>
- <span class="keyword">let</span> n = <span class="constructor">List</span>.length input_beam <span class="keyword">in</span><br>
- <span class="keyword">let</span> subtree1 = subtree_left dimension_tree <span class="keyword">in</span><br>
- <span class="keyword">let</span> subtree2 = subtree_right dimension_tree <span class="keyword">in</span><br>
- <span class="keyword">let</span> d1 = get_root subtree1 <span class="keyword">in</span><br>
- <span class="keyword">let</span> d2 = get_root subtree2 <span class="keyword">in</span><br>
-<br>
-<br>
- <span class="keyword">if</span> n = fst d1 <span class="keyword">then</span><br>
- (<br>
- <span class="comment">(* evaluate the first expression *)</span><br>
- <span class="keyword">let</span> output_beam1 = eval e1 subtree1 input_beam <span class="keyword">in</span><br>
-<br>
- <span class="comment">(* beam matching *)</span><br>
- <span class="keyword">let</span> input_beam2 = <br>
- (<br>
- <span class="keyword">let</span> fois = (snd d1)/(fst d2) <span class="keyword">in</span><br>
- <span class="keyword">let</span> ref_beam = ref (sublist output_beam1 0 (fst d2)) <span class="keyword">in</span><br>
- <span class="keyword">for</span> i = 1 <span class="keyword">to</span> fois - 1 <span class="keyword">do</span><br>
- <span class="keyword">let</span> temp_beam = sublist output_beam1 (i*(fst d2)) (fst d2) <span class="keyword">in</span><br>
- ref_beam := <span class="constructor">List</span>.map2 signal_add (!ref_beam) temp_beam;<br>
- <span class="keyword">done</span>;<br>
- !ref_beam<br>
- )<br>
- <span class="keyword">in</span><br>
-<br>
- <span class="comment">(* evaluate the second expression *)</span><br>
- <span class="keyword">if</span> <span class="constructor">List</span>.length input_beam2 = fst d2<br>
- <span class="keyword">then</span> eval e2 subtree2 input_beam2<br>
- <span class="keyword">else</span> raise (<span class="constructor">Evaluation_Error</span> <span class="string">"Merge"</span>)<br>
- )<br>
- <span class="keyword">else</span> raise (<span class="constructor">Evaluation_Error</span> <span class="string">"Merge"</span>) <span class="keyword">in</span><br>
-<br>
-<br>
-</code><table><tr><td></td><td><span class="comment">(** val interpret_rec : faust_exp -> faust_exp -> beam -> beam,
-interprets rec(e1, e2) with input beam, produces output beam.*)</span></td></tr></table><code class="code"><br>
-<span class="keyword">let</span> interpret_rec = <span class="keyword">fun</span> e1 <span class="keywordsign">-></span> <span class="keyword">fun</span> e2 <span class="keywordsign">-></span> <span class="keyword">fun</span> dimension_tree <span class="keywordsign">-></span> <span class="keyword">fun</span> input_beam <span class="keywordsign">-></span><br>
-<br>
- <span class="comment">(* dimension information *)</span><br>
- <span class="keyword">let</span> subtree1 = subtree_left dimension_tree <span class="keyword">in</span><br>
- <span class="keyword">let</span> subtree2 = subtree_right dimension_tree <span class="keyword">in</span><br>
- <span class="keyword">let</span> d1 = get_root subtree1 <span class="keyword">in</span><br>
- <span class="keyword">let</span> d2 = get_root subtree2 <span class="keyword">in</span><br>
-<br>
- <span class="comment">(* estimate stockage size for delay *)</span><br>
- <span class="keyword">let</span> delay_int = 1 + delay e2 + delay e1 <span class="keyword">in</span><br>
-<br>
- <span class="comment">(* prepare stockage *)</span><br>
- <span class="keyword">let</span> memory_hashtbl = <span class="constructor">Hashtbl</span>.create delay_int <span class="keyword">in</span><br>
- <span class="keyword">let</span> rate_list = ref (<span class="constructor">Array</span>.to_list (<span class="constructor">Array</span>.make (snd d1) 0)) <span class="keyword">in</span><br>
-<br>
- </code><table><tr><td> </td><td><span class="comment">(** val apply_to : 'a -> ('a -> 'b) -> 'b *)</span></td></tr></table><code class="code"><br>
- <span class="keyword">let</span> apply_to = <span class="keyword">fun</span> t <span class="keywordsign">-></span> <span class="keyword">fun</span> f <span class="keywordsign">-></span> f t <span class="keyword">in</span><br>
-<br>
- </code><table><tr><td> </td><td><span class="comment">(** val get_value_fun_list : (int -> (int list) * (value list)) -> (int -> value) list *)</span></td></tr></table><code class="code"> <br>
- <span class="keyword">let</span> get_value_fun_list = <span class="keyword">fun</span> beam_fun <span class="keywordsign">-></span> <br>
- <span class="keyword">let</span> tmp = <span class="keyword">fun</span> beam_fun <span class="keywordsign">-></span> <span class="keyword">fun</span> i <span class="keywordsign">-></span> <span class="keyword">fun</span> t <span class="keywordsign">-></span> <br>
- <span class="constructor">List</span>.nth (snd (beam_fun t)) i <span class="keyword">in</span><br>
- <span class="constructor">List</span>.map (tmp beam_fun) (<span class="constructor">Array</span>.to_list (<span class="constructor">Array</span>.init (snd d1) (<span class="keyword">fun</span> n <span class="keywordsign">-></span> n))) <span class="keyword">in</span><br>
-<br>
- </code><table><tr><td> </td><td><span class="comment">(** val make_signal : int -> (int -> value) -> signal, combines rate and function. *)</span></td></tr></table><code class="code"><br>
- <span class="keyword">let</span> make_signal = <span class="keyword">fun</span> rate <span class="keywordsign">-></span> <span class="keyword">fun</span> f <span class="keywordsign">-></span> (rate, f) <span class="keyword">in</span><br>
-<br>
- </code><table><tr><td> </td><td><span class="comment">(** val output_beam_fun : int -> (int list) * (value list), with
- input : time
- output: rate list * value list *)</span></td></tr></table><code class="code"><br>
- <span class="keyword">let</span> <span class="keyword">rec</span> output_beam_fun = <span class="keyword">fun</span> t <span class="keywordsign">-></span><br>
-<br>
- <span class="comment">(* initial value in constrctor "rec '~'" *)</span><br>
- <span class="keyword">if</span> t < 0 <span class="keyword">then</span><br>
- <span class="keyword">let</span> init_rate_list = <span class="constructor">Array</span>.to_list (<span class="constructor">Array</span>.make (snd d1) 0) <span class="keyword">in</span><br>
- <span class="keyword">let</span> value_list = <span class="constructor">Array</span>.to_list (<span class="constructor">Array</span>.make (snd d1) <span class="constructor">Zero</span>) <span class="keyword">in</span><br>
- (init_rate_list, value_list)<br>
-<br>
- <span class="comment">(* check stockage at time t *)</span><br>
- <span class="keyword">else</span> <span class="keyword">if</span> <span class="constructor">Hashtbl</span>.mem memory_hashtbl t <span class="keyword">then</span> <br>
- (!rate_list, <span class="constructor">Hashtbl</span>.find memory_hashtbl t)<br>
-<br>
- <span class="comment">(* blocks : "a ~ b", calculate rate list and value list at time t *)</span><br>
- <span class="keyword">else</span> <br>
- <span class="comment">(* mid_output_fun_list : (int -> value) list *)</span><br>
- <span class="keyword">let</span> mid_output_fun_list = get_value_fun_list output_beam_fun <span class="keyword">in</span><br>
-<br>
- <span class="comment">(* b_input_fun_list : (int -> value) list *)</span><br>
- <span class="keyword">let</span> b_input_fun_list = <span class="constructor">List</span>.map <br>
- (<span class="keyword">fun</span> s <span class="keywordsign">-></span> <span class="keyword">fun</span> t <span class="keywordsign">-></span> s (t - 1)) <br>
- (sublist mid_output_fun_list 0 (fst d2)) <span class="keyword">in</span><br>
-<br>
- <span class="comment">(* b_input_beam : signal list *)</span><br>
- <span class="keyword">let</span> b_input_beam = <span class="constructor">List</span>.map2 make_signal <br>
- (sublist !rate_list 0 (fst d2))<br>
- b_input_fun_list <span class="keyword">in</span><br>
-<br>
- <span class="comment">(* evaluation of block "b" *)</span><br>
- <span class="keyword">let</span> b_output_beam = (eval e2 subtree2 b_input_beam) <span class="keyword">in</span><br>
-<br>
- <span class="comment">(* evaluation of block "a" *)</span><br>
- <span class="keyword">let</span> a_input_beam = b_output_beam @ input_beam <span class="keyword">in</span><br>
- <span class="keyword">let</span> mid_output_beam = eval e1 subtree1 a_input_beam <span class="keyword">in</span><br>
-<br>
- <span class="comment">(* calculate rate list and value list at time t *)</span><br>
- <span class="keyword">let</span> mid_output_rate_list = <span class="constructor">List</span>.map fst mid_output_beam <span class="keyword">in</span><br>
- <span class="keyword">let</span> mid_output_value_list = <span class="constructor">List</span>.map (apply_to t) (<span class="constructor">List</span>.map snd mid_output_beam) <span class="keyword">in</span><br>
-<br>
- <span class="comment">(* update stockage *)</span><br>
- <span class="keyword">let</span> () = (rate_list := mid_output_rate_list) <span class="keyword">in</span><br>
- <span class="keyword">let</span> () = <span class="constructor">Hashtbl</span>.add memory_hashtbl t mid_output_value_list <span class="keyword">in</span><br>
- <span class="keyword">let</span> () = <span class="constructor">Hashtbl</span>.remove memory_hashtbl (t - delay_int) <span class="keyword">in</span><br>
- (mid_output_rate_list, mid_output_value_list) <span class="keyword">in</span><br>
-<br>
- <span class="comment">(* output_beam : signal list *)</span><br>
- <span class="keyword">let</span> output_beam = <span class="constructor">List</span>.map2 make_signal !rate_list (get_value_fun_list output_beam_fun) <span class="keyword">in</span><br>
- output_beam <span class="keyword">in</span><br>
-<br>
-<br>
- </code><table><tr><td> </td><td><span class="comment">(** Call for previous functions *)</span></td></tr></table><code class="code"><br>
- <span class="keyword">match</span> exp_faust <span class="keyword">with</span><br>
- <span class="keywordsign">|</span><span class="constructor">Const</span> v <span class="keywordsign">-></span> interpret_const v input_beam<br>
- <span class="keywordsign">|</span><span class="constructor">Ident</span> s <span class="keywordsign">-></span> interpret_ident s input_beam<br>
- <span class="keywordsign">|</span><span class="constructor">Par</span> (e1, e2) <span class="keywordsign">-></span> interpret_par e1 e2 dimension_tree input_beam<br>
- <span class="keywordsign">|</span><span class="constructor">Seq</span> (e1, e2) <span class="keywordsign">-></span> interpret_seq e1 e2 dimension_tree input_beam<br>
- <span class="keywordsign">|</span><span class="constructor">Split</span> (e1, e2) <span class="keywordsign">-></span> interpret_split e1 e2 dimension_tree input_beam<br>
- <span class="keywordsign">|</span><span class="constructor">Merge</span> (e1, e2) <span class="keywordsign">-></span> interpret_merge e1 e2 dimension_tree input_beam<br>
- <span class="keywordsign">|</span><span class="constructor">Rec</span> (e1, e2) <span class="keywordsign">-></span> interpret_rec e1 e2 dimension_tree input_beam</code></body></html>
\ No newline at end of file