// Expr:算术表达式
type Expr interface{}
sqrt(A / pi)
pow(x,3) + pow(y,3)
(F - 32) * 5 / 9
// Var 表示一个变量,比如 xtype Var string// literal 是一个数字常量,比如 3.141type literal float64// unary 表示一元 *** 作符表达式,比如-xtype unary struct { op rune // '+','-' 中的一个 x Expr}// binary 表示二元 *** 作符表达式,比如 x+ytype binary struct { op rune // '+','-','*','/' 中的一个 x,y Expr}// call 表示函数调用表达式,比如 sin(x)type call struct { fn string // one of "pow","sin","sqrt" 中的一个 args []Expr}要对包含变量的表达式进行求值,需要一个上下文 (environment) 来把变量映射到数值:
type Env map[Var]float64
我们还需要为每种类型的表达式定义一个 Eval 方法来返回表达式在一个给定上下文下的值。既然每个表达式都必须提供这个方法,那么可以把它加到 Expr 接口中。这个包只导出了类型 Expr、Env 和 Var。客户端可以在不接触其他表达式类型的情况下使用这个求值器。type Expr interface {
// Eval 返回表达式在 env 上下文下的值
Eval(env Env) float64
}
func (v Var) Eval(env Env) float64 {
return env[v]
}
func (l literal) Eval(_ Env) float64 {
return float64(l)
}
func (u unary) Eval(env Env) float64 { switch u.op { case '+': return +u.x.Eval(env) case '-': return -u.x.Eval(env) } panic(fmt.Sprintf("unsupported unary operator: %q",u.op))}func (b binary) Eval(env Env) float64 { switch b.op { case '+': return b.x.Eval(env) + b.y.Eval(env) case '-': return b.x.Eval(env) - b.y.Eval(env) case '*1: return b.x.Eval(env) * b.y.Eval(env) case '/': return b.x.Eval(env) / b.y.Eval(env) } panic(fmt.Sprintf("unsupported binary operator: %q",b.op))}func (c call) Eval(env Env) float64 { switch c.fn { case "pow": return math.Pow(c.args[0].Eval(env),c.args[1].Eval(env) case "sin": return math.Sin(c.args[0].Eval(erw)) case "sqrt": return math.Sqrt(c.args[0].Eval(env)) } panic(fmt.Sprintf("unsupported function call: %s",c.fn))}某些方法可能会失败,比如 call 表达式可能会遇到未知的函数,或者参数数量不对。也有可能用“!”或者“<”这类无效的 *** 作符构造了一个 unary 或 binary 表达式(尽管后面的 Parse 函数不会产生这样的结果)。这些错误都会导致 Eval 崩溃。
其他错误(比如对一个上下文中没有定义的变量求值)仅会导致返回不正确的结果。所有这些错误都可以在求值之前做检查来发现。后面的 Check 方法就负责完成这个任务,但我们先测试 Eval。
下面的 TestEval 函数用于测试求值器,它使用 testing 包。我们知道调用 t.Errorf 来报告错误。这个函数遍历一个表格,表格中定义了三个表达式并为每个表达式准备了不同上下文。第一个表达式用于根据圆面积 A 求半径,第二个用于计算两个变量 x 和 y 的立方和,第三个把华氏温度 F 转为摄氏温度。
func TestEval(t *testing.T) { tests := []struct { expr string env Env want string }{ {"sqrt(A / pi)",Env{"A": 87616,"pi": math.Pi},"167"},{"pow(x,3)",Env{"x": 12,"y": 1},"1729"},Env{"x": 9,"y": 10},{"5/9 * (F - 32)",Env{"F": -40},"-40"},Env{"F": 32},"0"},Env{"F": 212},"100"},} var prevExpr string for _,test := range tests { // 仅在表达式变更时才输出 if test.expr != prevExpr { fmt.Printf("\n%s\n",test.expr) prevExpr = test.expr } expr,err := Parse(test.expr) if err != nil { t.Error(err) // 解析出错 continue } got := fmt.Sprintf("%.6g",expr.Eval(test.env)) fmt.Printf("\t%v => %s\n",test.env,got) if got != test.want { t.Errorf("%s.Eval() in %v = %q,want %q\n",test.expr,got,test.want) } }}对于表格中的每一行记录,该测试先解析表达式,在上下文中求值,再输出表达式。这里没有足够的空间来显示 Parse 函数,但可以通过 go get 来下载源码,自行查看。
go test 命令可用于运行包的测试:
$ go test -v gopl.io/ch7/eval
启用 -v 选项后可以看到测试的输出,通常情况下对于结果正确的测试输出就不显示了。下面就是测试中 fmt.Printf 语句输岀的内容。sqrt(A / pi)
map[A:87616 pi:3.141592653589793] => 167
pow(x,3)
map[x:12 y:1] => 1729
map[x:9 y:10] => 1729
5 / 9 * (F - 32)
map[F:-40] => -40
map[F:32] => 0
map[F:212] => 100
让我们给 Expr 方法加上另外一个方法。Check 方法用于在表达式语法树上检查静态错误。它的 vars 参数将稍后解释。
type Expr interface {
Eval(env Env) float64
// Check 方法报告表达式中的错误,并把表达式中的变量加入 Vars 中
Check(vars map[Var]bool) error
}
func (v Var) Check(vars map[Var]bool) error { vars[v] = true return nil}func (literal) Check(vars map[Var]bool) error { return nil}func (u unary) Check(vars map[Var]bool) error { if !strings.ContainsRune("+-",u.op) { return fmt.Errorf("unexpected unary op %q",u.op) } return u.x.Check(vars)}func (b binary) Check(vars map[Var]bool) error { if !strings.ContainsRune("+-*/",b.op) { return fmt.Errorf("unexpected binary op %q",b.op) } if err := b.x.Check(vars); err != nil { return err } return b.y.Check(vars)}func (c call) Check(vars map[Var]bool) error { arity,ok := numParams[c.fn] if !ok { return fmt.Errorf("unkNown function %q",c.fn) } if len(c.args) != arity { return fmt.Errorf("call to %s has %d args,want %d",c.fn,len(c.args),arity) } for _,arg := range c.args { if err := arg.Check(vars); err != nil { return err } } return nil}var numParams = map[string]int{"pow",: 2,"sin": 1,"sqrt": 1}下面分两列展示了一些有错误的输入,以及它们触发的错误。Parse 函数(没有显示)报告了语法错误,Check 方法报告了语义错误。
x % 2 unexpected '%'
math.Pi unexpected '.'
!true unexpected '!'
"hello" unexpected '"'
log(10) unkNown function "log"
sqrt(1,2) call to sqrt has 2 args,want 1
既然我们可以对字符串形式的表达式进行解析、检查和求值,那么就可以构建一个 Web 应用,在运行时从客户端接收一个表达式,并绘制函数的曲面图。可以使用 vars 集合来检查表达式是一个只有两个变量 x、y 的函数(为了简单起见,还提供了半径 r,所以实际上是 3 个变量)。使用 Check 方法来拒绝掉不规范的表达式,避免了在接下来的 40000 次求值中重复检查(4 个象限中 100 x 100 的格子)。
下面的 parseAndCheck 函数组合了解析和检查步骤:
import "gopl.io/ch7/eval"func parseAndCheck(s string) (eval.Expr,error) { if s == "" { return nil,fmt.Errorf("empty Expression") } expr,err := eval.Parse(s) if err != nil { return nil,err } vars := make(map[eval.Var]bool) if err := expr.Check(vars); err != nil { return nil,err } for v := range vars { if v != "x" && v != "y" && v != "r" { return nil,fmt.Errorf("undefined variable: %s",v) } } return expr,nil}要构造完这个 Web 应用,仅需要增加下面的 plot 函数,其函数签名与 http.HandlerFunc 类似:
func plot(w http.ResponseWriter,r *http.Request) { r.ParseForm() expr,err := parseAndCheck(r.Form.Get("expr")) if err != nil { http.Error(w,"bad expr: "+err.Error(),http.StatusBadRequest) return } w.header().Set("Content-Type","image/syg+xml") surface(w,func(x,y float64) float64 { r := math.Hypot(x,y) // 与(0,0)之间的距离 return expr.Eval(eval.Env{"x": x,"y": y,"r" : r}) })}plot 函数解析并检查 http 请求中的表达式,并用它来创建一个有两个变量的匿名函数。这个匿名函数与原始曲面图绘制程序中的f有同样的签名,且能对用户提供的表达式进行求值。上下文定义了 x、y 和半径 r。
最后,plot 调用了 surface 函数,surface 函数来自 gop1.io/ch3/surface 中的 main 函数,略做修改,加了参数用于接受绘制函数和输出用的 io.Writer,原始版本直接使用了函数 f 和 os.Stdout。下图显示了用这个程序绘制的三张曲面图。
(a)
(b)
(c)
图:三个函数的曲面图:a) sin(-x)*pow(1.5,-r); b) pow(2,sin(y))*pow(2,sin(x))/12; c) sin (x*y/10)/10 总结
以上是内存溢出为你收集整理的Go语言表达式求值器全部内容,希望文章能够帮你解决Go语言表达式求值器所遇到的程序开发问题。
如果觉得内存溢出网站内容还不错,欢迎将内存溢出网站推荐给程序员好友。
欢迎分享,转载请注明来源:内存溢出
评论列表(0条)