标签: postfix-notation

我正在编写甚至可能在python中称为语言的东西.我目前有几家运营商:+,-,*,^,fac,@,!!.fac计算阶乘,@返回变量的值,!!设置变量.代码如下.我将如何编写一种用这种简单语言定义函数的方法？

编辑:我更新了代码!

import sys, shlex, readline, os, string
List, assign, call, add, sub, div, Pow, mul, mod, fac, duf, read,\
kill, clr, STO, RET, fib, curs = {}, "set", "get", "+", "-", "/", "^", "*",\
"%", "fact", "func", "read", "kill", "clear", ">", "@", "fib", "vars"
def fact(num):
    if num == 1: return 1
    else: return num*fact(num-1)
def Simp(op, num2, num1): …

我为我的Java类创建了一个堆栈计算器来解决方程式

2 + ( 2 * ( 10 – 4 ) / ( ( 4 * 2 / ( 3 + 4) ) + 2 ) – 9 )
2 + { 2 * ( 10 – 4 ) / [ { 4 * 2 / ( 3 + 4) } + 2 ] – 9 }

我们假设要{ } [ ]在我们的代码中实现.我只用括号做了.它只用100%工作( ).当我尝试添加时{ } [ ],它会变成香蕉.

这是我到目前为止:

package stackscalc;

import java.util.Scanner;
import java.util.Stack;
import java.util.EmptyStackException; …

在查看可以在c中的同一语句中的同一变量上有一个递增器和递减器

我发现你可以在一个变量上有几个前缀增量/减量运算符,但只有一个后缀

例如:

++--++foo; // valid
foo++--++; // invalid
--foo++;   // invalid

为什么是这样？

好的,我必须从文件中读取后缀表达式.后缀表达式必须具有空格以分隔每个运算符或操作数.到目前为止,只有在输入文件中的运算符或操作数之间没有空格时,我才能使用它.(即如果文件有12+,我得到的结果是3.)为了做到这一点,我认为我需要对输入进行标记化,但我不确定如何.这就是我到目前为止所拥有的.感谢您的回复.

import java.util.*;
import java.io.*;
public class PostfixCalc{
public static void main (String [] args) throws Exception {
File file = new File("in.txt");
Scanner sc = new Scanner(file);
String input = sc.next();
Stack<Integer> calc = new Stack<Integer>();
while(sc.hasNext()){
for(int i = 0; i < input.length(); i++){
    char c = input.charAt(i);
    int x = 0;
    int y = 0;
    int r = 0;
    if(Character.isDigit(c)){
       int t = Character.getNumericValue(c);
        calc.push(t);
    }
    else if(c == '+'){
        x = calc.pop();
        y = calc.pop();
        r …

通过使用我的意思是它在许多计算器如HP35-中使用

我的猜测(和混淆)是 -

1. postfix实际上是更高效的内存 - (所以在这里发表评论).(混淆 - 两者的评估算法与堆栈类似)
2. 当时计算器中的键盘输入类型(混淆 - 这应该不重要,因为它只取决于第一个或最后一个给定的运算符的顺序)

可以问这个问题的另一种方式是后缀表示法优于前缀的优点是什么？
任何人都可以开导我吗？

我正在尝试使用AST python模块将python数学表达式转换为postfix表示法.这是我到目前为止所得到的:

import parser
import ast
from math import sin, cos, tan

formulas = [
    "1+2",
    "1+2*3",
    "1/2",
    "(1+2)*3",
    "sin(x)*x**2",
    "cos(x)",
    "True and False",
    "sin(w*time)"
]


class v(ast.NodeVisitor):

    def __init__(self):
        self.tokens = []

    def f_continue(self, node):
        super(v, self).generic_visit(node)

    def visit_Add(self, node):
        self.tokens.append('+')
        self.f_continue(node)

    def visit_And(self, node):
        self.tokens.append('&&')
        self.f_continue(node)

    def visit_BinOp(self, node):
        # print('visit_BinOp')
        # for child in ast.iter_fields(node):
            # print('  child %s ' % str(child))

        self.f_continue(node)

    def visit_BoolOp(self, node):
        # print('visit_BoolOp')
        self.f_continue(node)

    def visit_Call(self, node):
        # print('visit_Call')
        self.f_continue(node)

    def visit_Div(self, …

我一直在看维基页面:http://en.wikipedia.org/wiki/Shunting-yard_algorithm

我已经使用代码示例来构建第一部分,基本上我现在可以转向:

3 + 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3 成 3 4 2 * 1 5 ? 2 3 ^ ^ / +

但我不知道如何使用3 4 2 * 1 5 ? 2 3 ^ ^ / +获取3.00012207

并且wiki上的示例代码和解释对我没有任何意义.

有人可以解释如何评估3 4 2 * 1 5 ? 2 3 ^ ^ / +和产生答案.提前致谢.我不需要代码示例只是一个很好的解释或示例的细分.

这不重要,但我正在工作.net C#.

我有一个字符串,其中包含一个自定义表达式,我必须解析和评估:

例如:

(FUNCTION_A(5,4,5) UNION FUNCTION_B(3,3)) 
INTERSECT (FUNCTION_C(5,4,5) UNION FUNCTION_D(3,3))

FUNCTION_X表示在C#中实现并返回IList的函数.UNION或INTERSECT是自定义函数,应该应用于从这些函数返回的列表.

联盟和交叉是通过实现的Enumerable.Intersect/Enumerable.Union.

如何以优雅和可扩展的方式实现解析和评估？

假设我有

my %foo;

我可以通过取一个切片并使用后缀表示法进行并行分配来设置 keys foo, bar, baztoa b c吗？

%foo->@{qw/foo bar baz/} = qw/a b c/

我使用了这种语法，我被告知它只是“意外工作”。我没有看到它产生警告，我也没有看到它在任何地方记录。这种行为是否受支持？

背景：在传统的 Reverse Polish Notation 中，所有的操作符都必须有固定的长度，这使得 RPN 可以很容易地被代码评估和操作，因为每个标记、表达式和子表达式都是“自包含”的，以至于人们可以盲目地将yin替换x?y?*为y?1?+to get x?y?1?+?*，这是另一个有效的表达式，它完全符合您的要求。这是一个带有命名变量支持的简单 RPN 计算器的交互式演示。请注意，演示试图展示算法的要点；它们与生产代码无关或不代表生产代码。

var rpn = prompt("Please enter RPN string, where each token is " +
  "separated by a space", "x 1 x + * 2 /").trim().split(/\s+/);

var stack = [], variables = [], values = [];
for (let i = 0, len = rpn.length|0; i < len; i=i+1|0) {
    if (/^\d*(\.\d*)?$/.test(rpn[i]) && rpn[i] !== "") {
        stack.push( rpn[i] );
    } else if (/^[a-z]$/i.test(rpn[i])) …