α-wwwiki

α-wwwiki :: history/regexp_evaluator/20130708-070958.txt

editor : alpha [82.249.27.227] 2013/07/08 07:09:58
_h1 evaluator{sup 3}
{div {@ style="font:bold 1.0em georgia;text-align:center;color:red;background:#eee;box-shadow:0 0 8px black;"} [[basic_evaluator]] | [[extended_evaluator]] | regexp_evaluator | [[alphalisp|data/alphalisp/]]}

_p Following the architecture of the alphawiki's parser engine (see [[JS.js|meca/JS.js]]), this is a multi s-expressions evaluator based on a unique loop catching the s-expressions through a unique RegExp and coming with the special operator "def" allowing to extend the set of basic functions. There are two dictionaries :
_ul the initial {b jsdico} with functions whose body is in javascript code, for instance : {b jsdico['js_mult'] = function(a,b) °°{ return a*b }°°;}
_ul the {b lsdico} storing the user functions via the "def" operator ; the function's body ùust be written with valid s-expressions, for instance : {b jsdico['ls_mult'] = °°{args:'x,y', body:'(* x y)'}°°;}.
_p  {b Caution!} Today, in order to prevent any evaluation at the define time, the round parenthesis "()" inside the body must be replaced by square brackets "[]" to prevent any evaluation at the define step. Tomorrow it may change !-) This is how to use the console :
_ul first "init the evaluator", only once,
_ul copy some s-expressions from the examples in the code,
_ul paste it into the field below,
_ul then click on the button "evaluate"
_ul and do it again with new values.
{hr}

{textarea {@ id="input" style="width:99%;height:200px;background:#ffe;font:normal 1em courier;"}
(def pytha [x y] 
  [sqrt 
    [+ 
      [* x x] 
      [* y y]
    ]
  ]
)
(pytha 3 4)
}
First {input {@ type="submit" value="init evaluator" onclick="°° 
  var js = document.createElement('script');
  var input = getId('code').innerHTML;
  js.innerHTML = decode_html_entities(input); // < ,>
  document.head.appendChild( js );
  this.value = 'OK, evaluator inited !'; 
  this.disabled='disabled';
°°"}}
 then {input {@ type="submit" value="evaluate" onclick="do_evaluate()"}}
{pre {@ id="output"}}

_h3 examples
{pre

// 1) basic operators

(+ 1 2 3 4 5 6) -> 21
(* 1 2 3 4 5 6) -> 720
(- 1) -> -1
(- 1 2) -> -1
(/ 3) -> 0.3333333333333333
(/ 1 2) -> 0.5
(/ 1 2 2) -> 0.25
(/ 1 2 2 2) -> 0.125

(+  
  (* 3 3) 
  (* 4 4)
) -> 25

(++ 3) -> 4
(-- 3) -> 2
(<  1 2) -> true
(> 1 2) -> false
(= 1.0 1.000) -> true
(not true) -> false
(and true false) -> false
(or true false) -> true

/////////////////////////////////
// 2) the JS Math functions

(sqrt  2) -> 1.4142135623730951
(pow 2 8) -> 256
(log (E)) -> 1
(exp 1) -> 2.718281828459045
(max 1 3 2 23 1 56) -> 56
(min -10 3 2 23 1 56) -> 10
(acos 1) -> 0

(sqrt 
  (+ 
    (* 3 3) 
    (* 4 4)
  )
) -> 5

(+ 
  (square (cos 0)) 
  (square (sin 0))
)

/////////////////////////////////
// 3) the core defined user functions

(square 12) -> 144
(hypo 3 4) -> 5
(fac 6) -> 720
(rand 1000) -> an integer in [1 1000)

/////////////////////////////////
// 4) inline defined user functions

// 41) defining a constant
(def myPI [] 3.1416)
(myPI) -> 3.141592653589793

// 42) defining a function with one argument
(def carre [x] [* x x])
(carre 12) -> 144

// 43) defining a function with two arguments
(def pytha [x y] 
  [sqrt 
    [+ 
      [* x x] 
      [* y y]
    ]
  ]
)
(pytha 3 4) -> 5

}
_h3 evaluator's code

{pre {@ id="code"}°°
// 1) HTML interface

function do_evaluate() {
  var input = getId('input').value;
  getId('output').innerHTML = doLoop(input);
}

// 2) parser

// 3) dictionaries

var lsdico = {}; // the body is made of s-expressions

lsdico['add'] = {args:'x,y', body:'(+ x y)'};
lsdico['mult'] = {args:'x,y', body:'(* x y)'};
lsdico['pythagore'] = {args:'x,y', body:'(sqrt (add (mult x x) (mult y y)))'};
// which will be followed by the user defined functions

var jsdico = {}; // the body is made of javascript code (the primitives)

// basic operators
jsdico['+'] = function() { 
  for (var r=0, i=0; i< arguments.length; i++) 
    r += Number(arguments[i]); 
  return r; 
};
jsdico['*'] = function() { 
  for (var r=1, i=0; i< arguments.length; i++) 
    r *= arguments[i]; 
  return r; 
};
jsdico['-'] = function () { // (- 1 2 3 4) -> 1-2-3-4
  var r = arguments[0];
  if (arguments.length == 1) 
    r = -r;  // case (- 1) -> -1
  else
    for (var i=1; i< arguments.length; i++) 
      r -= arguments[i]; 
  return r; 
};
jsdico['/'] = function () { // (/ 1 2 3 4) -> 1/2/3/4
  var r = arguments[0];
  if (arguments.length == 1) 
    r = 1/r;  // case (/ 2) -> 1/2
  else
    for (var i=1; i< arguments.length; i++) 
      r /= arguments[i]; 
  return r; 
};
jsdico['++'] = function(a) { return a + 1 }; // (++ 3) -> 4
jsdico['--'] = function(a) { return a - 1 }; // (-- 3) -> 2
jsdico['>'] = function(a,b) { return a > b }; // (> 2 1) -> true
jsdico['< '] = function(a,b) { return a< b }; // (< 2 1) -> false
jsdico['='] = function(a,b) { return !(a< b) && !(b< a) }; // (= 1 1) -> true
jsdico['not'] = function (a) { return !a }; // (not (= 1 1)) -> false
jsdico['or'] = function () {  // (or (= 1 1) (= 1 2)) -> true
  for (var ret=false, i=0; i< arguments.length; i++)
    if (arguments[i])
      return true;
  return ret;
};
jsdico['and'] = function () { // (and (= 1 1) (= 1 2)) -> false 
  for (var ret=true, i=0; i< arguments.length; i++)
    if (!arguments[i])
      return false;
  return ret;
};

// JS Math functions 
var mathfns = ['abs', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'exp',
'floor', 'log', 'max', 'min', 'pow', 'random', 'round', 'sin', 'sqrt', 'tan'];
for (var i=0; i< mathfns.length; i++)
  jsdico[mathfns[i]] = Math[mathfns[i]];
jsdico['PI'] = function () { return Math.PI; };
jsdico['E'] = function ()  { return Math.E; };
// some user JS functions
jsdico['square'] = function(a) { return a*a };
jsdico['hypo'] = function(a,b) { return Math.sqrt(a*a+b*b) };
jsdico['fac'] = function(a) { return (a< 2)? 1 : a*arguments.callee(a-1); };
jsdico['rand'] = function(a) { return Math.floor((Math.random()*a)+1) }; // in [1,a]
jsdico['mod'] = function(a,b) { return a % b };
// and so on ...

°°}