Skip to content

Instantly share code, notes, and snippets.

@jcbozonier

jcbozonier/gist:5608523

Forked from anonymous/gist:5608522
Last active December 17, 2015 12:19
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save jcbozonier/5608523 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save jcbozonier/5608523 to your computer and use it in GitHub Desktop.
Download ZIP

Revisions

  1. jcbozonier revised this gist May 19, 2013. 1 changed file with 85 additions and 1 deletion.
    86 changes: 85 additions & 1 deletion gistfile1.js
    View file
    Original file line number Diff line number Diff line change
    @@ -16,16 +16,37 @@
    case '*':
    tokens.push({'type':'operator', 'value':'*'});
    break;
    case '/':
    tokens.push({'type':'operator', 'value':'/'});
    break;
    case '+':
    tokens.push({'type':'operator', 'value':'+'});
    break;
    case '-':
    tokens.push({'type':'operator', 'value':'-'});
    break;
    case 'n':
    tokens.push({'type': 'constant', 'value':parseFloat(buffer)});
    buffer = '';
    break;
    case 'x':
    tokens.push({'type': 'input_constant'});
    break;
    case 'q':
    tokens.push({'type': 'operator', 'value':'q'});
    break;
    case 's':
    tokens.push({'type': 'operator', 'value':'s'});
    break;
    case 'c':
    tokens.push({'type': 'operator', 'value':'c'});
    break;
    case 't':
    tokens.push({'type': 'operator', 'value':'t'});
    break;
    case '^':
    tokens.push({'type': 'operator', 'value':'^'});
    break;
    default:
    var constant_pattern=/[0-9\.]/
    if(constant_pattern.test(character)){
    @@ -38,9 +59,9 @@
    }

    }

    return tokens;
    };

    var DivisionOperator = function(left_node, right_node){
    return {
    'evaluate':function(input_constant){
    @@ -69,6 +90,13 @@
    }
    };
    };
    var PowerOperator = function(left_node, right_node){
    return {
    'evaluate':function(input_constant){
    return Math.pow(left_node.evaluate(input_constant), right_node.evaluate(input_constant));
    }
    };
    };
    var ConstantTerm = function(constant_value){
    return {
    'evaluate': function(input_constant){
    @@ -83,6 +111,35 @@
    }
    }
    };
    var SquareRootOperator = function(node){
    return {
    'evaluate': function(input_constant){
    return Math.sqrt(node.evaluate(input_constant));
    }
    }
    };
    var SineOperator = function(node){
    return {
    'evaluate': function(input_constant){
    return Math.sin(node.evaluate(input_constant));
    }
    }
    };
    var CosineOperator = function(node){
    return {
    'evaluate': function(input_constant){
    return Math.cos(node.evaluate(input_constant));
    }
    }
    };
    var TangentOperator = function(node){
    return {
    'evaluate': function(input_constant){
    return Math.tan(node.evaluate(input_constant));
    }
    }
    };

    var parse_these = function(tokens){
    tokens = tokens.slice(0);

    @@ -119,6 +176,32 @@
    var operator_node = new DivisionOperator(left_term, right_term);
    nodes_to_assemble.push(operator_node);
    break;
    case '^':
    var right_term = nodes_to_assemble.shift();
    var left_term = nodes_to_assemble.shift();
    var operator_node = new PowerOperator(left_term, right_term);
    nodes_to_assemble.push(operator_node);
    break;
    case 'q':
    var term = nodes_to_assemble.shift();
    var operator_node = new SquareRootOperator(term);
    nodes_to_assemble.push(operator_node);
    break;
    case 's':
    var term = nodes_to_assemble.shift();
    var operator_node = new SineOperator(term);
    nodes_to_assemble.push(operator_node);
    break;
    case 'c':
    var term = nodes_to_assemble.shift();
    var operator_node = new CosineOperator(term);
    nodes_to_assemble.push(operator_node);
    break;
    case 't':
    var term = nodes_to_assemble.shift();
    var operator_node = new TangentOperator(term);
    nodes_to_assemble.push(operator_node);
    break;
    }
    break;
    case 'constant':
    @@ -139,6 +222,7 @@
    }
    return nodes_to_assemble[0];
    };

    var evaluate_chromosome = function(chromosome, x){
    console.log("In evaluate_chromosome");
    var tokens = lex_this(chromosome);
  2. jcbozonier revised this gist May 19, 2013. 1 changed file with 160 additions and 160 deletions.
    320 changes: 160 additions & 160 deletions gistfile1.js
    View file
    Original file line number Diff line number Diff line change
    @@ -2,180 +2,180 @@
    <html>
    <head>
    <title>Monte Carlo Calculus</title>
    <script src="script/monte_carlo.js"></script>
    <script>
    var lex_this = function(chromosome){
    var tokens = [];
    chromosome = chromosome.split('').slice(0);
    <script src="script/monte_carlo.js"></script>
    <script>
    var lex_this = function(chromosome){
    var tokens = [];
    chromosome = chromosome.split('').slice(0);

    var buffer = '';
    for(var index=chromosome.length-1; index >= 0; index--){
    var character = chromosome[index];
    console.log(character);
    switch(character){
    case '*':
    tokens.push({'type':'operator', 'value':'*'});
    break;
    case '+':
    tokens.push({'type':'operator', 'value':'+'});
    break;
    case 'n':
    tokens.push({'type': 'constant', 'value':parseFloat(buffer)});
    buffer = '';
    break;
    case 'x':
    tokens.push({'type': 'input_constant'});
    break;
    default:
    var constant_pattern=/[0-9\.]/
    if(constant_pattern.test(character)){
    buffer = character + buffer;
    console.log('Buffer is now: ' + buffer);
    } else {
    throw 'Unexpected value of ' + character;
    }
    break;
    }
    }
    return tokens;
    };
    var DivisionOperator = function(left_node, right_node){
    return {
    'evaluate':function(input_constant){
    return left_node.evaluate(input_constant) / right_node.evaluate(input_constant);
    }
    };
    };
    var MultiplicationOperator = function(left_node, right_node){
    return {
    'evaluate':function(input_constant){
    return left_node.evaluate(input_constant) * right_node.evaluate(input_constant);
    }
    };
    };
    var AdditionOperator = function(left_node, right_node){
    return {
    'evaluate':function(input_constant){
    return left_node.evaluate(input_constant) + right_node.evaluate(input_constant);
    }
    };
    };
    var SubtractionOperator = function(left_node, right_node){
    return {
    'evaluate':function(input_constant){
    return left_node.evaluate(input_constant) - right_node.evaluate(input_constant);
    }
    };
    };
    var ConstantTerm = function(constant_value){
    return {
    'evaluate': function(input_constant){
    return constant_value;
    }
    };
    };
    var InputConstantTerm = function(){
    return {
    'evaluate': function(input_constant){
    return input_constant;
    }
    }
    };
    var parse_these = function(tokens){
    tokens = tokens.slice(0);
    var buffer = '';
    for(var index=chromosome.length-1; index >= 0; index--){
    var character = chromosome[index];
    console.log(character);
    switch(character){
    case '*':
    tokens.push({'type':'operator', 'value':'*'});
    break;
    case '+':
    tokens.push({'type':'operator', 'value':'+'});
    break;
    case 'n':
    tokens.push({'type': 'constant', 'value':parseFloat(buffer)});
    buffer = '';
    break;
    case 'x':
    tokens.push({'type': 'input_constant'});
    break;
    default:
    var constant_pattern=/[0-9\.]/
    if(constant_pattern.test(character)){
    buffer = character + buffer;
    console.log('Buffer is now: ' + buffer);
    } else {
    throw 'Unexpected value of ' + character;
    }
    break;
    }
    }
    return tokens;
    };
    var DivisionOperator = function(left_node, right_node){
    return {
    'evaluate':function(input_constant){
    return left_node.evaluate(input_constant) / right_node.evaluate(input_constant);
    }
    };
    };
    var MultiplicationOperator = function(left_node, right_node){
    return {
    'evaluate':function(input_constant){
    return left_node.evaluate(input_constant) * right_node.evaluate(input_constant);
    }
    };
    };
    var AdditionOperator = function(left_node, right_node){
    return {
    'evaluate':function(input_constant){
    return left_node.evaluate(input_constant) + right_node.evaluate(input_constant);
    }
    };
    };
    var SubtractionOperator = function(left_node, right_node){
    return {
    'evaluate':function(input_constant){
    return left_node.evaluate(input_constant) - right_node.evaluate(input_constant);
    }
    };
    };
    var ConstantTerm = function(constant_value){
    return {
    'evaluate': function(input_constant){
    return constant_value;
    }
    };
    };
    var InputConstantTerm = function(){
    return {
    'evaluate': function(input_constant){
    return input_constant;
    }
    }
    };
    var parse_these = function(tokens){
    tokens = tokens.slice(0);

    console.log(tokens);
    var nodes_to_assemble = [];
    console.log(tokens);
    var nodes_to_assemble = [];

    for(var index in tokens){
    var token = tokens[index];
    for(var index in tokens){
    var token = tokens[index];

    switch(token.type){
    case 'operator':
    switch(token.value){
    case '+':
    var right_term = nodes_to_assemble.shift();
    var left_term = nodes_to_assemble.shift();
    var operator_node = new AdditionOperator(left_term, right_term);
    nodes_to_assemble.push(operator_node);
    break;
    case '-':
    var right_term = nodes_to_assemble.shift();
    var left_term = nodes_to_assemble.shift();
    var operator_node = new SubtractionOperator(left_term, right_term);
    nodes_to_assemble.push(operator_node);
    break;
    case '*':
    var right_term = nodes_to_assemble.shift();
    var left_term = nodes_to_assemble.shift();
    var operator_node = new MultiplicationOperator(left_term, right_term);
    nodes_to_assemble.push(operator_node);
    break;
    case '/':
    var right_term = nodes_to_assemble.shift();
    var left_term = nodes_to_assemble.shift();
    var operator_node = new DivisionOperator(left_term, right_term);
    nodes_to_assemble.push(operator_node);
    break;
    }
    break;
    case 'constant':
    var constant = new ConstantTerm(token.value);
    nodes_to_assemble.push(constant);
    break;
    case 'input_constant':
    var input_constant = new InputConstantTerm();
    nodes_to_assemble.push(input_constant);
    break;
    default:
    throw 'Unexpected token type ' + token.type;
    break;
    }
    }
    if(nodes_to_assemble.length > 1){
    throw 'Invalid AST. Ambiguous root node';
    }
    return nodes_to_assemble[0];
    };
    var evaluate_chromosome = function(chromosome, x){
    console.log("In evaluate_chromosome");
    var tokens = lex_this(chromosome);
    console.log("Token count: " + tokens.length);
    console.log("Tokens: " + JSON.stringify(tokens));
    var ast = parse_these(tokens);
    return ast.evaluate(parseFloat(x));
    };
    switch(token.type){
    case 'operator':
    switch(token.value){
    case '+':
    var right_term = nodes_to_assemble.shift();
    var left_term = nodes_to_assemble.shift();
    var operator_node = new AdditionOperator(left_term, right_term);
    nodes_to_assemble.push(operator_node);
    break;
    case '-':
    var right_term = nodes_to_assemble.shift();
    var left_term = nodes_to_assemble.shift();
    var operator_node = new SubtractionOperator(left_term, right_term);
    nodes_to_assemble.push(operator_node);
    break;
    case '*':
    var right_term = nodes_to_assemble.shift();
    var left_term = nodes_to_assemble.shift();
    var operator_node = new MultiplicationOperator(left_term, right_term);
    nodes_to_assemble.push(operator_node);
    break;
    case '/':
    var right_term = nodes_to_assemble.shift();
    var left_term = nodes_to_assemble.shift();
    var operator_node = new DivisionOperator(left_term, right_term);
    nodes_to_assemble.push(operator_node);
    break;
    }
    break;
    case 'constant':
    var constant = new ConstantTerm(token.value);
    nodes_to_assemble.push(constant);
    break;
    case 'input_constant':
    var input_constant = new InputConstantTerm();
    nodes_to_assemble.push(input_constant);
    break;
    default:
    throw 'Unexpected token type ' + token.type;
    break;
    }
    }
    if(nodes_to_assemble.length > 1){
    throw 'Invalid AST. Ambiguous root node';
    }
    return nodes_to_assemble[0];
    };
    var evaluate_chromosome = function(chromosome, x){
    console.log("In evaluate_chromosome");
    var tokens = lex_this(chromosome);
    console.log("Token count: " + tokens.length);
    console.log("Tokens: " + JSON.stringify(tokens));
    var ast = parse_these(tokens);
    return ast.evaluate(parseFloat(x));
    };

    var main = function(){
    var chromosome = document.getElementById('chromosome').value;
    var x = Number(document.getElementById('x').value);
    var main = function(){
    var chromosome = document.getElementById('chromosome').value;
    var x = Number(document.getElementById('x').value);

    var result = evaluate_chromosome(chromosome, x);
    var result = evaluate_chromosome(chromosome, x);

    var result_field = document.getElementById('chromosome_result');
    result_field.innerHTML = result;
    };
    </script>
    var result_field = document.getElementById('chromosome_result');
    result_field.innerHTML = result;
    };
    </script>
    </head>
    <body>
    Evaluating chromosome<br />
    <ul>
    <li>
    Chromosome: <input type="text" id="chromosome" value="+x*+xn2n31"/>
    </li>
    <li>
    X: <input type="text" id="x" value="0"/>
    </li>
    <li>
    <input id="get_results" type="button" value="Calculate" />
    </li>
    <li>
    Chromosome: <input type="text" id="chromosome" value="+x*+xn2n31"/>
    </li>
    <li>
    X: <input type="text" id="x" value="0"/>
    </li>
    <li>
    <input id="get_results" type="button" value="Calculate" />
    </li>
    </ul>
    Result: <span id="chromosome_result"></span>
    <script>
    var button = document.getElementById('get_results');
    button.onclick = main;
    var button = document.getElementById('get_results');
    button.onclick = main;
    </script>
    </body>
    </html>
  3. @invalid-email-address Anonymous created this gist May 19, 2013.
    181 changes: 181 additions & 0 deletions gistfile1.js
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,181 @@

    <html>
    <head>
    <title>Monte Carlo Calculus</title>
    <script src="script/monte_carlo.js"></script>
    <script>
    var lex_this = function(chromosome){
    var tokens = [];
    chromosome = chromosome.split('').slice(0);

    var buffer = '';
    for(var index=chromosome.length-1; index >= 0; index--){
    var character = chromosome[index];
    console.log(character);
    switch(character){
    case '*':
    tokens.push({'type':'operator', 'value':'*'});
    break;
    case '+':
    tokens.push({'type':'operator', 'value':'+'});
    break;
    case 'n':
    tokens.push({'type': 'constant', 'value':parseFloat(buffer)});
    buffer = '';
    break;
    case 'x':
    tokens.push({'type': 'input_constant'});
    break;
    default:
    var constant_pattern=/[0-9\.]/
    if(constant_pattern.test(character)){
    buffer = character + buffer;
    console.log('Buffer is now: ' + buffer);
    } else {
    throw 'Unexpected value of ' + character;
    }
    break;
    }

    }

    return tokens;
    };
    var DivisionOperator = function(left_node, right_node){
    return {
    'evaluate':function(input_constant){
    return left_node.evaluate(input_constant) / right_node.evaluate(input_constant);
    }
    };
    };
    var MultiplicationOperator = function(left_node, right_node){
    return {
    'evaluate':function(input_constant){
    return left_node.evaluate(input_constant) * right_node.evaluate(input_constant);
    }
    };
    };
    var AdditionOperator = function(left_node, right_node){
    return {
    'evaluate':function(input_constant){
    return left_node.evaluate(input_constant) + right_node.evaluate(input_constant);
    }
    };
    };
    var SubtractionOperator = function(left_node, right_node){
    return {
    'evaluate':function(input_constant){
    return left_node.evaluate(input_constant) - right_node.evaluate(input_constant);
    }
    };
    };
    var ConstantTerm = function(constant_value){
    return {
    'evaluate': function(input_constant){
    return constant_value;
    }
    };
    };
    var InputConstantTerm = function(){
    return {
    'evaluate': function(input_constant){
    return input_constant;
    }
    }
    };
    var parse_these = function(tokens){
    tokens = tokens.slice(0);

    console.log(tokens);
    var nodes_to_assemble = [];

    for(var index in tokens){
    var token = tokens[index];

    switch(token.type){
    case 'operator':
    switch(token.value){
    case '+':
    var right_term = nodes_to_assemble.shift();
    var left_term = nodes_to_assemble.shift();
    var operator_node = new AdditionOperator(left_term, right_term);
    nodes_to_assemble.push(operator_node);
    break;
    case '-':
    var right_term = nodes_to_assemble.shift();
    var left_term = nodes_to_assemble.shift();
    var operator_node = new SubtractionOperator(left_term, right_term);
    nodes_to_assemble.push(operator_node);
    break;
    case '*':
    var right_term = nodes_to_assemble.shift();
    var left_term = nodes_to_assemble.shift();
    var operator_node = new MultiplicationOperator(left_term, right_term);
    nodes_to_assemble.push(operator_node);
    break;
    case '/':
    var right_term = nodes_to_assemble.shift();
    var left_term = nodes_to_assemble.shift();
    var operator_node = new DivisionOperator(left_term, right_term);
    nodes_to_assemble.push(operator_node);
    break;
    }
    break;
    case 'constant':
    var constant = new ConstantTerm(token.value);
    nodes_to_assemble.push(constant);
    break;
    case 'input_constant':
    var input_constant = new InputConstantTerm();
    nodes_to_assemble.push(input_constant);
    break;
    default:
    throw 'Unexpected token type ' + token.type;
    break;
    }
    }
    if(nodes_to_assemble.length > 1){
    throw 'Invalid AST. Ambiguous root node';
    }
    return nodes_to_assemble[0];
    };
    var evaluate_chromosome = function(chromosome, x){
    console.log("In evaluate_chromosome");
    var tokens = lex_this(chromosome);
    console.log("Token count: " + tokens.length);
    console.log("Tokens: " + JSON.stringify(tokens));
    var ast = parse_these(tokens);
    return ast.evaluate(parseFloat(x));
    };

    var main = function(){
    var chromosome = document.getElementById('chromosome').value;
    var x = Number(document.getElementById('x').value);

    var result = evaluate_chromosome(chromosome, x);

    var result_field = document.getElementById('chromosome_result');
    result_field.innerHTML = result;
    };
    </script>
    </head>
    <body>
    Evaluating chromosome<br />
    <ul>
    <li>
    Chromosome: <input type="text" id="chromosome" value="+x*+xn2n31"/>
    </li>
    <li>
    X: <input type="text" id="x" value="0"/>
    </li>
    <li>
    <input id="get_results" type="button" value="Calculate" />
    </li>
    </ul>
    Result: <span id="chromosome_result"></span>
    <script>
    var button = document.getElementById('get_results');
    button.onclick = main;
    </script>
    </body>
    </html>