(* tests for ME/script.sml

   TODO.WN0509 collect typical tests from systest here !!!!!

   author: Walther Neuper 050908

   (c) copyright due to lincense terms.

use"../smltest/ME/script.sml";

use"script.sml";

*)

"-----------------------------------------------------------------";

"table of contents -----------------------------------------------";

"-----------------------------------------------------------------";

"----------- WN0509 why does next_tac doesnt find Substitute -----";

"----------- WN0509 Substitute 2nd part --------------------------";

"----------- fun sel_appl_atomic_tacs ----------------------------";

"-----------------------------------------------------------------";

"-----------------------------------------------------------------";

"-----------------------------------------------------------------";

"----------- WN0509 why does next_tac doesnt find Substitute -----";

"----------- WN0509 why does next_tac doesnt find Substitute -----";

"----------- WN0509 why does next_tac doesnt find Substitute -----";

(*replace met 'IntegrierenUndKonstanteBestimmen' with this script...*)

val str = (*#1#*)

"Script BiegelinieScript                                             \

\(l_::real) (q__::real) (v_::real) (b_::real=>real)                    \

\(rb_::bool list) (rm_::bool list) =                                  \

\  (let q___ = Take (M_b v_v = q__);                                          \

\       (M1__::bool) = ((Substitute [v_ = 0])) q___           \

\ in True)";

val sc' = ((inst_abs thy) o term_of o the o (parse thy)) str;

val str = (*#2#*)

"Script BiegelinieScript                                             \

\(l_::real) (q__::real) (v_::real) (b_::real=>real)                    \

\(rb_::bool list) (rm_::bool list) =                                  \

\  (let q___ = Take (q_ v_v = q__);                                          \

\       (M1__::bool) = ((Substitute [v_ = 0]) @@ \

\                       (Substitute [M_b 0 = 0]))  q___          \

\ in True)";(*..doesnt find Substitute with ..@@ !!!!!!!!!!!!!!!!!!!!!*)

val str = (*#3#*)

"Script BiegelinieScript                                             \

\(l_::real) (q__::real) (v_::real) (b_::real=>real)                    \

\(rb_::bool list) (rm_::bool list) =                                  \

\  (let q___ = Take (q_ v_v = q__);                                          \

\      (M1__::bool) = Substitute [v_ = 0]      q___ ;        \

\       M1__ =        Substitute [M_b 0 = 0]  M1__           \

\ in True)"

;

val str = (*#4#*)

"Script BiegelinieScript                                             \

\(l_::real) (q__::real) (v_::real) (b_::real=>real)                    \

\(rb_::bool list) (rm_::bool list) =                                  \

\  (let q___ = Take (q_ v_v = q__);                                          \

\      (M1__::bool) = Substitute [v_ = 0]      q___ ;        \

\       M1__ =        Substitute [v_ = 1]      q___ ;        \

\       M1__ =        Substitute [v_ = 2]      q___ ;        \

\       M1__ =        Substitute [v_ = 3]      q___ ;        \

\       M1__ =        Substitute [M_b 0 = 0]  M1__           \

\ in True)"

;

val str = (*#5#*)

"Script BiegelinieScript                                             \

\(l_::real) (q__::real) (v_::real) (b_::real=>real)                    \

\(rb_::bool list) (rm_::bool list) =                                  \

\  (let q___ = Take (M_b v_v = q__);                                          \

\      (M1__::bool) = Substitute [v_ = 0]      q___ ;        \

\       M2__ = Take q___ ;                                     \

\       M2__ =        Substitute [v_ = 2]      q___           \

\ in True)"

;

val sc' = ((inst_abs thy) o term_of o the o (parse thy)) str;

atomty sc';

val {scr=Script sc,...} = get_met ["IntegrierenUndKonstanteBestimmen"];

(*---------------------------------------------------------------------

if sc = sc' then () else error"script.sml, doesnt find Substitute #1";

---------------------------------------------------------------------*)

val fmz = ["Traegerlaenge L",

	   "Streckenlast (- q_0 * x^^^2 / 2 + x * c + c_2)",

	   "Biegelinie y",

	   "RandbedingungenBiegung [y 0 = 0, y L = 0]",

	   "RandbedingungenMoment [M_b 0 = 0, M_b L = 0]",

	   "FunktionsVariable x"];

val (dI',pI',mI') =

  ("Biegelinie.thy",["MomentBestimmte","Biegelinien"],

   ["IntegrierenUndKonstanteBestimmen"]);

val p = e_pos'; val c = [];

val (p,_,f,nxt,_,pt) = CalcTreeTEST [(fmz, (dI',pI',mI'))];

val (p,_,f,nxt,_,pt) = me nxt p c pt;val (p,_,f,nxt,_,pt) = me nxt p c pt;

val (p,_,f,nxt,_,pt) = me nxt p c pt;val (p,_,f,nxt,_,pt) = me nxt p c pt;

val (p,_,f,nxt,_,pt) = me nxt p c pt;val (p,_,f,nxt,_,pt) = me nxt p c pt;

val (p,_,f,nxt,_,pt) = me nxt p c pt;val (p,_,f,nxt,_,pt) = me nxt p c pt;

val (p,_,f,nxt,_,pt) = me nxt p c pt;val (p,_,f,nxt,_,pt) = me nxt p c pt;

val (p,_,f,nxt,_,pt) = me nxt p c pt;

val (p,_,f,nxt,_,pt) = me nxt p c pt;

case nxt of (_, Apply_Method ["IntegrierenUndKonstanteBestimmen"]) => ()

	  | _ => error "script.sml, doesnt find Substitute #2";

val (p,_,f,nxt,_,pt) = me nxt p c pt; f2str f;

(* *** generate1: not impl.for Substitute' !!!!!!!!!!(*#1#*)!!!!!!!!!!!*)

(* val nxt = ("Check_Postcond",.. !!!!!!!!!!!!!!!!!!!(*#2#*)!!!!!!!!!!!*)

val (p,_,f,nxt,_,pt) = me nxt p c pt; f2str f;

(* *** generate1: not impl.for Empty_Tac_  !!!!!!!!!!(*#3#*)!!!!!!!!!!!*)

val (p,_,f,nxt,_,pt) = me nxt p c pt; f2str f;

val (p,_,f,nxt,_,pt) = me nxt p c pt; f2str f;

val (p,_,f,nxt,_,pt) = me nxt p c pt; f2str f;

(*---------------------------------------------------------------------*)

case nxt of (_, End_Proof') => () 

	  | _ => error "script.sml, doesnt find Substitute #3";

(*---------------------------------------------------------------------*)

(*the reason, that next_tac didnt find the 2nd Substitute, was that

  the Take inbetween was missing, and thus the 2nd Substitute was applied

  the last formula in ctree, and not to argument from script*)

"----------- WN0509 Substitute 2nd part --------------------------";

"----------- WN0509 Substitute 2nd part --------------------------";

"----------- WN0509 Substitute 2nd part --------------------------";

(*replace met 'IntegrierenUndKonstanteBestimmen' with this script...*)

val str = (*Substitute ; Substitute works*)

"Script BiegelinieScript                                             \

\(l_::real) (q__::real) (v_::real) (b_::real=>real)                    \

\(rb_::bool list) (rm_::bool list) =                                  "^

(*begin after the 2nd integrate*)

"  (let M__ = Take (M_b v_v = q__);                                     \

\       e1__ = nth_ 1 rm_ ;                                         \

\       (x1__::real) = argument_in (lhs e1__);                       \

\       (M1__::bool) = Substitute [v_ = x1__] M__;                   \

\        M1__        = Substitute [e1__] M1__                    \

\ in True)"

;

(*---^^^-OK-----------------------------------------------------------------*)

val sc' = ((inst_abs thy) o term_of o the o (parse thy)) str;

atomty sc';

(*---vvv-NOT ok-------------------------------------------------------------*)

val str = (*Substitute @@ Substitute does NOT work???*)

"Script BiegelinieScript                                             \

\(l_::real) (q__::real) (v_::real) (b_::real=>real)                    \

\(rb_::bool list) (rm_::bool list) =                                  "^

(*begin after the 2nd integrate*)

"  (let M__ = Take (M_b v_v = q__);                                     \

\       e1__ = nth_ 1 rm_ ;                                         \

\       (x1__::real) = argument_in (lhs e1__);                       \

\       (M1__::bool) = ((Substitute [v_ = x1__]) @@ \

\                       (Substitute [e1__]))        M__           \

\ in True)"

;

val {scr=Script sc,...} = get_met ["IntegrierenUndKonstanteBestimmen"];

(*---------------------------------------------------------------------

if sc = sc' then () else error"script.sml, doesnt find Substitute #1";

---------------------------------------------------------------------*)

val fmz = ["Traegerlaenge L",

	   "Streckenlast (- q_0 * x^^^2 / 2 + x * c + c_2)",

	   "Biegelinie y",

	   "RandbedingungenBiegung [y 0 = 0, y L = 0]",

	   "RandbedingungenMoment [M_b 0 = 0, M_b L = 0]",

	   "FunktionsVariable x"];

val (dI',pI',mI') =

  ("Biegelinie.thy",["MomentBestimmte","Biegelinien"],

   ["IntegrierenUndKonstanteBestimmen"]);

val p = e_pos'; val c = [];

val (p,_,f,nxt,_,pt) = CalcTreeTEST [(fmz, (dI',pI',mI'))];

val (p,_,f,nxt,_,pt) = me nxt p c pt;val (p,_,f,nxt,_,pt) = me nxt p c pt;

val (p,_,f,nxt,_,pt) = me nxt p c pt;val (p,_,f,nxt,_,pt) = me nxt p c pt;

val (p,_,f,nxt,_,pt) = me nxt p c pt;val (p,_,f,nxt,_,pt) = me nxt p c pt;

val (p,_,f,nxt,_,pt) = me nxt p c pt;val (p,_,f,nxt,_,pt) = me nxt p c pt;

val (p,_,f,nxt,_,pt) = me nxt p c pt;val (p,_,f,nxt,_,pt) = me nxt p c pt;

val (p,_,f,nxt,_,pt) = me nxt p c pt;

val (p,_,f,nxt,_,pt) = me nxt p c pt;

case nxt of (_, Apply_Method ["IntegrierenUndKonstanteBestimmen"]) => ()

	  | _ => error "script.sml, doesnt find Substitute #2";

trace_rewrite:=true;

val (p,_,f,nxt,_,pt) = me nxt p c pt; f2str f(*------------------------*);

trace_rewrite:=false;

(*Exception TYPE raised:

Illegal type for constant "op =" :: "[real, bool] => bool"

Atools.argument'_in (Tools.lhs (ListG.nth_ (1 + -1 + -1) [])) =

ListG.nth_ (1 + -1 + -1) []

Exception-

   TYPE

      ("Illegal type for constant \"op =\" :: \"[real, bool] => bool\"",

         [],

         [Const ("Trueprop", "bool => prop") $

               (Const ("op =", "[RealDef.real, bool] => bool") $ ... $ ...)])

   raised

... this was because eval_argument_in took "argument_in (lhs (M_b 0 = 0))"

ie. the argument had not been simplified before          ^^^^^^^^^^^^^^^

thus corrected eval_argument_in OK*)

val {srls,...} = get_met ["IntegrierenUndKonstanteBestimmen"];

val e1__ = str2term"nth_ 1 [M_b 0 = 0, M_b L = 0]";

val e1__ = eval_listexpr_ Biegelinie.thy srls e1__; term2str e1__;

if term2str e1__ = "M_b 0 = 0" then () else 

error"script.sml diff.beh. eval_listexpr_ nth_ 1 [...";

(*TODO.WN050913 ??? doesnt eval_listexpr_ go into subterms ???...

val x1__ = str2term"argument_in (lhs (M_b 0 = 0))";

val x1__ = eval_listexpr_ Biegelinie.thy srls x1__; term2str x1__;

(*no rewrite*)

calculate_ Biegelinie.thy ("Tools.lhs", eval_rhs"eval_lhs_") x1__;

val SOME (str, t) = eval_lhs 0 "Tools.lhs" (str2term"lhs (M_b 0 = 0)") 0;*)

val l__ = str2term"lhs (M_b 0 = 0)";

val l__ = eval_listexpr_ Biegelinie.thy srls l__; term2str l__;

val SOME (str, t) = eval_lhs 0 "Tools.lhs" (str2term"lhs (M_b 0 = 0)") 0;

trace_rewrite:=true;

val (p,_,f,nxt,_,pt) = me nxt p c pt; f2str f(*------------------------*);

trace_rewrite:=false;

show_mets();

"----------- fun sel_appl_atomic_tacs ----------------------------";

"----------- fun sel_appl_atomic_tacs ----------------------------";

"----------- fun sel_appl_atomic_tacs ----------------------------";

states:=[];

CalcTree

[(["equality (x+1=2)", "solveFor x","solutions L"], 

  ("Test.thy", 

   ["sqroot-test","univariate","equation","test"],

   ["Test","squ-equ-test-subpbl1"]))];

Iterator 1;

moveActiveRoot 1;

autoCalculate 1 CompleteCalcHead;

autoCalculate 1 (Step 1);

autoCalculate 1 (Step 1);

val ((pt, p), _) = get_calc 1; show_pt pt;

val appltacs = sel_appl_atomic_tacs pt p;

if appltacs = 

   [Rewrite ("radd_commute", "?m + ?n = ?n + ?m"),

    Rewrite ("radd_assoc", "?m + ?n + ?k = ?m + (?n + ?k)"),

    Calculate "times"] then ()

else error "script.sml fun sel_appl_atomic_tacs diff.behav.";

trace_script := true;

trace_script := false;

applyTactic 1 p (hd appltacs);

val ((pt, p), _) = get_calc 1; show_pt pt;

val appltacs = sel_appl_atomic_tacs pt p;

"----- WN080102 these vvv do not work, because locatetac starts the search\

 \1 stac too low";

applyTactic 1 p (hd appltacs);

autoCalculate 1 CompleteCalc;