Arithmetic evaluation: Difference between revisions

 

;Requirements:

=={{header|11l}}==

[[wp:Pratt parser|Pratt parser]]

String id

Int lbp

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - A68RS has not implemented forward declarations}}

MODE FIXED = LONG REAL; # numbers in the format 9,999.999 #

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

hand coded recursive descent parser

expr : term ( ( PLUS | MINUS ) term )* ;

 

#include calclex.ahk</syntaxhighlight>

{

stringo := string ; store original string

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

PRINT "Input = " Expr$

AST$ = FNast(Expr$)

 

{{libheader|Boost.Spirit|1.8.4}}

#include <boost/spirit/tree/ast.hpp>

#include <string>

 

=={{header|Clojure}}==

+ 1, - 1})

 

This implementation can read integers, and produce integral and rational values.

 

(labels ((whitespace-p (char)

(find char #(#\space #\newline #\return #\tab)))

=={{header|D}}==

After the AST tree is constructed, a visitor pattern is used to display the AST structure and calculate the expression value.

std.exception, std.traits;

 

=={{header|Dyalect}}==

 

with Lookup

 

While the task requirements specify not evaluating using the language's built-in eval, they don't say that you have to write your own ''parser''...

 

def LiteralExpr := <elang:evm.makeLiteralExpr>.asType()

def arithEvaluate(expr :String) {

Parentheses are handled by the parser.

 

# value: 3

 

=={{header|Elena}}==

ELENA 5.0 :

import extensions;

import extensions'text;

 

=={{header|Emacs Lisp}}==

;; -*- mode: emacs-lisp; lexical-binding: t -*-

;;> ./arithmetic-evaluation '(1 + 2) * 3'

 

=={{header|ERRE}}==

PROGRAM EVAL

 

 

<code>AbstractSyntaxTree.fs</code>:

type Expression =

 

<code>Lexer.fsl</code>:

module Lexer

 

 

<code>Parser.fsy</code>:

open AbstractSyntaxTree

%}

 

<code>Program.fs</code>:

open Lexer

open Parser

 

=={{header|Factor}}==

IN: rosetta.arith

 

 

=={{header|FreeBASIC}}==

'Arithmetic evaluation

'

=={{header|Groovy}}==

Solution:

ADD('+', 2),

SUBTRACT('-', 2),

 

Test:

def ex = parse(it)

print """

 

=={{header|Haskell}}==

 

import Text.Parsec

* Notice that the code looks remarkably like a typical grammar, rather than being an opaque cryptic solution

* Does not rely on any library to silently solve 1/2 the problem; in fact, this code would probably suit being put into a library almost verbatim

write("Usage: Input expression = Abstract Syntax Tree = Value, ^Z to end.")

repeat {

The implementation here uses a shift/reduce parser to build a tree structure for evaluation (a tree structure which J happens to support for evaluation):

 

eval=:monad define

'gerund structure'=:y

)</syntaxhighlight>

example use:

2.2</syntaxhighlight>

 

You can also display the syntax tree, for example:

┌─────────────────────────────────────────────────────┬───────────────────┐

│┌───┬───────┬───┬───────┬───┬─┬───────┬───┬───────┬─┐│┌───────┬─┬───────┐│

Uses the [[Arithmetic/Rational/Java|BigRational class]] to handle arbitrary-precision numbers (rational numbers since basic arithmetic will result in rational values).

 

 

public class ArithmeticEvaluation {

Spaces are removed, expressions like <code>5--1</code> are treated as <code>5 - -1</code>

 

s = s.replace(/\s/g,'').replace(/^\+/,'');

var rePara = /\([^\(\)]*\)/;

 

=== PEG operations ===

def plus(E): E | (plus(E) // . );

def optional(E): E // .;

 

=== Helper functions ===

select(.remainder | startswith($s))

| .result += [$s]

 

=== PEG Grammar ===

 

def ws: consume(" *");

 

=== Evaluation ===

def eval:

if type == "array" then

From Javascript entry.

 

function evalArithmeticExp(s) {

s = s.replace(/\s/g,'').replace(/^\+/,'');

=={{header|Julia}}==

Julia's homoiconic nature and strong metaprogramming facilities make AST/Expression parsing and creation as accessible and programmatic as other language features

"2 * (3 -1) + 2 * 5"

 

=={{header|Kotlin}}==

{{trans|JavaScript}}

 

/* if string is empty, returns zero */

 

=={{header|Liberty BASIC}}==

'[RC] Arithmetic evaluation.bas

'Buld the tree (with linked nodes, in array 'cause LB has no pointers)

=={{header|Lua}}==

 

 

P, R, C, S, V = lpeg.P, lpeg.R, lpeg.C, lpeg.S, lpeg.V

All visible variables can be used, and all known functions, internal and user (if they are visible at that point). Global variables and functions are always visible.

 

y=100

Module CheckEval {

From BBC BASIC. In M2000 we can't call a user function which isn't a child function, so here we make all functions as members of same group, so now they call each other. A function as a member in a group can use other members, using a dot or This and a dot, so .Ast$() is same as This.Ast$().

 

Module CheckAst {

Group Eval {

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

parse[string_] :=

Module[{e},

 

Example use:

evaluate["-1+2(3+4*-5/6)"]</syntaxhighlight>

 

 

=={{header|MiniScript}}==

Expr.eval = 0

 

This implementation uses a Pratt parser.

 

import os

 

=={{header|OCaml}}==

 

| Const of float

| Sum of expression * expression (* e1 + e2 *)

Using the function <code>read_expression</code> in an interactive loop:

 

while true do

print_string "Expression: ";

 

=={{header|ooRexx}}==

expressions = .array~of("2+3", "2+3/4", "2*3-4", "2*(3+4)+5/6", "2 * (3 + (4 * 5 + (6 * 7) * 8) - 9) * 10", "2*-3--4+-.25")

loop input over expressions

The <code>Do</code> procedure automatically threads the input state through a sequence of procedure calls.

 

 

fun {Expr X0 ?X}

 

=={{header|Perl}}==

# Evaluates an arithmetic expression like "(1+3)*7" and returns

# its value.

plus this as asked for has an AST, whereas Phix uses cross-linked flat IL.

See also [[Arithmetic_evaluation/Phix]] for a translation of the D entry.

<span style="color: #000080;font-style:italic;">-- demo\rosetta\Arithmetic_evaluation.exw</span>

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

 

=={{header|Picat}}==

print("Enter an expression: "),

Str = read_line(),

(numbers and transient symbols). From that, a recursive descendent parser can

build an expression tree, resulting in directly executable Lisp code.

(let *L (str Str "")

(aggregate) ) )

((= "(" X) (prog1 (aggregate) (pop '*L)))) ) )</syntaxhighlight>

{{out}}

-> (+ (+ 1 2) (/ (* 3 (- 4)) (+ 1 2)))

 

=={{header|Pop11}}==

 

/* Uncomment the following to parse data from standard input

 

=={{header|Prolog}}==

{{works with|SWI Prolog 8.1.19}}

numeric(X) :- 48 =< X, X =< 57.

not_numeric(X) :- 48 > X ; X > 57.

<br>A subsequent example uses Pythons' ast module to generate the abstract syntax tree.

 

 

class AstNode(object):

===ast standard library module===

Python comes with its own [http://docs.python.org/3.1/library/ast.html#module-ast ast] module as part of its standard libraries. The module compiles Python source into an AST tree that can in turn be compiled to bytecode then executed.

>>>

>>> expr="2 * (3 -1) + 2 * 5"

=={{header|Racket}}==

 

 

(require parser-tools/yacc

{{Works with|rakudo|2018.03}}

 

 

grammar expr {

:::* &nbsp; 12.3D+44 &nbsp; &nbsp; &nbsp; ("double" precision)

:::* &nbsp; 12.3Q+44 &nbsp; &nbsp; &nbsp; ("extended" or "quad" precision)

nchars = '0123456789.eEdDqQ' /*possible parts of a number, sans ± */

e='***error***'; $=" "; doubleOps= '&|*/'; z= /*handy─dandy variables.*/

=={{header|Ruby}}==

Function to convert infix arithmetic expression to binary tree. The resulting tree knows how to print and evaluate itself. Assumes expression is well-formed (matched parens, all operators have 2 operands). Algorithm: http://www.seas.gwu.edu/~csci131/fall96/exp_to_tree.html

 

class TreeNode

end</syntaxhighlight>

Testing:

puts("Original: " + exp)

 

 

=={{header|Rust}}==

 

 

is practically non-existent, to avoid obscuring the code.

 

package org.rosetta.arithmetic_evaluator.scala

 

The parse function uses a recursive-descent parser to follow the precedence rules.

 

(import (scheme base)

(scheme char)

=={{header|Sidef}}==

{{trans|JavaScript}}

 

func evalExp(s) {

 

Testing the function:

['2+3' => 5],

['-4-3' => -7],

This implementation uses a [https://en.wikipedia.org/wiki/Recursive_descent_parser recursive descent parser]. It first lexes the input. The parser builds a Abstract Syntax Tree (AST) and the evaluator evaluates it. The parser uses sub categories.

The parsing is a little bit tricky because the grammar is left recursive.

datatype expression =

Con of int (* constant *)

 

=={{header|Tailspin}}==

def ops: ['+','-','*','/'];

 

 

If we don't need to get the AST, we could just evaluate right away:

composer calculator

(<WS>?) <addition|multiplication|term> (<WS>?)

in a form that it can be immediately eval-led,

using Tcl's prefix operators.

 

proc ast str {

Use TXR text pattern matching to parse expression to a Lisp AST, then evaluate with <code>eval</code>:

 

@(define space)@/ */@(end)

@(define mulop (nod))@\

 

 

 

=={{header|Ursala}}==

with no error checking other than removal of spaces

#import nat

#import flo

 

test program:

 

test = evaluate*t

{{trans|Kotlin}}

{{libheader|Wren-pattern}}

 

/* if string is empty, returns zero */

=={{header|zkl}}==

In zkl, the compiler stack is part of the language and is written in zkl so ...

Compiler.Parser.parseText("1+3*7").dump();</syntaxhighlight>

The ASTs look like

</pre>

Evaluating them is just moving up the stack:

Compiler.Compiler.compileText("1+3*7").__constructor(); vm.regX;</syntaxhighlight>

{{out}}

 

=={{header|ZX Spectrum Basic}}==

20 LET s$="": REM last symbol

30 LET pc=0: REM parenthesis counter

310 STOP

</syntaxhighlight>