在ocaml中简化计算机代数系统的方程式

Question

IHello！ 我目前正在尝试在ocaml中编程一个程序，以绘制由用户编写的函数。

为此，我要解析输入，然后将输入转换为数据结构。 我目前正在尝试创建ocaml函数，以最大程度地简化此输入。

例如，x * x-x * x将简化为0

这是我的解析器：

%{
    open Function
%}

%token <float> FLOAT
%token <string> VAR
%token COS SIN SQRT EXP LN PUIS
%token PLUS MINUS TIMES DIV
%token LPAR RPAR
%token EOL
%left LPAR RPAR
%left COS SIN SQRT EXP LN
%left PLUS MINUS
%left TIMES DIV
%left PUIS
%type <Function.formel> main
%start main
%%

main:
expr EOL                    { $1 }
;

expr:
|   FLOAT                       { flt $1 }
|   VAR                         { var $1 }
|   FLOAT VAR                   { mul (flt $1) (var $2) }
|   LPAR expr RPAR              { $2 }
|   expr TIMES expr             { mul $1 $3 }
|   expr DIV expr               { div $1 $3 }
|   expr PLUS expr              { add $1 $3 }
|   expr MINUS expr             { sub $1 $3 }
|   expr PUIS expr              { puis $1 $3 }
|   COS LPAR expr RPAR          { cos $3 }
|   PLUS expr                   { pos $2 }
|   MINUS expr                  { neg $2 }
|   FLOAT COS LPAR expr RPAR    { mul (flt $1) (cos $4) }
|   SIN LPAR expr RPAR          { sin $3 }
|   FLOAT SIN LPAR expr RPAR    { mul (flt $1) (sin $4) }
|   SQRT LPAR expr RPAR         { sqrt $3 }
|   LN LPAR expr RPAR           { lnp $3 }
|   EXP LPAR expr RPAR          { expo $3 }
;

这是我的词法分析器：

{
    open Parser
    exception Eof
}

rule token = parse
  | [' ' '\t']          { token lexbuf }
  | ['\n']              { EOL }
  | ['0'-'9']+ as lxm   { FLOAT (float_of_string lxm) }
  | '+'                 { PLUS }
  | '-'                 { MINUS }
  | '*'                 { TIMES }
  | '/'                 { DIV }
  | '('                 { LPAR }
  | ')'                 { RPAR }
  | '^'                 { PUIS }
  | "cos"               { COS }
  | "sin"               { SIN }
  | "sqrt"              { SQRT }
  | "ln"                { LN }
  | "exp"               { EXP }
  | ['a'-'z']+ as lxm   { VAR (lxm) }
  | eof                 { raise Eof }

我认为解析器和词法分析器都很好。

然后，我使用一棵树来存储函数：

type formel =
| Float of float
| Var of string
| Add of formel * formel
| Sub of formel * formel
| Mul of formel * formel
| Div of formel * formel
| Ln of formel
| Cos of formel
| Sin of formel
| Puis of formel * formel
| Sqrt of formel
| Exp of formel

let flt f = Float f
let add e1 e2 = Add (e1, e2)
let sub e1 e2 = Sub (e1, e2)
let mul e1 e2 = Mul (e1, e2)
let div e1 e2 = Div (e1, e2)
let puis e1 e2 = Puis (e1, e2)
let neg e = Mul (Float (-1.), e)
let pos e = Mul (Float 1., e)
let cos e = Cos e
let sin e = Sin e
let var v = Var v
let sqrt e = Sqrt e
let expo e = Exp e
let lnp e = Ln e

这就是我面临的困难：创建一个简化的函数。

        let rec simplify f =
        let f_simplify = simp f in
        if f_simplify = f 
        then f_simplify 
        else simplify f_simplify
        and simp f = 
        match f with
        | Float f -> Float f
        | Var x -> Var x

        (* 0 + x -> x *)
        | Add (Float 0., f) -> simp f
        (* x + 0 -> x *)
        | Add (f, Float 0.) -> simp f
        (* f1 + f2-> calcul (f1 + f2) *)
        | Add (Float f1, Float f2) -> Float (f1 +. f2)
        (* x + x -> 2 * x *)
        | Add (f, g) when f = g -> simp (Mul (Float 2., simp f))

        (* f1 * x + x -> (f1 + 1) * x *)
        | Add (Mul (Float f1, f), g) when f = g -> simp (Mul (Float (f1 +. 1.), simp f))
        (* x + f1 * x -> (f1 + 1) * x *)
        | Add (f, Mul (Float f1, g)) when f = g -> simp (Mul (Float (f1 +. 1.), simp f))
        (* x * f1 + x -> (f1 + 1) * x *)
        | Add (Mul (f, Float f1), g) when f = g -> simp (Mul (Float (f1 +. 1.), simp f))
        (* x + x * f1 -> (f1 + 1) * x *)
        | Add (f, Mul (g, Float f1)) when f = g -> simp (Mul (Float (f1 +. 1.), simp f))

        (* f1 * x + f2 * x -> (f1 + f2) * x *)
        | Add (Mul (Float f1, f), Mul (Float f2, g)) when f = g -> simp (Mul (Float (f1 +. f2), simp f))
        (* x * f1 + f2 * x -> (f1 + f2) * x *)
        | Add (Mul (f, Float f1), Mul (Float f2, g)) when f = g -> simp (Mul (Float (f1 +. f2), simp f))
        (* f1 * x + x * f2 -> (f1 + f2) * x *)
        | Add (Mul (Float f1, f), Mul (g, Float f2)) when f = g -> simp (Mul (Float (f1 +. f2), simp f))
        (* x * f1 + x * f2 -> (f1 + f2) * x *)
        | Add (Mul (f, Float f1), Mul (g, Float f2)) when f = g -> simp (Mul (Float (f1 +. f2), simp f))

        | Add (f, g) -> Add (simp f, simp g)

        (* 0 - x -> - x *)
        | Sub (Float 0., f) -> simp (Mul (Float (-1.), simp f))
        (* x - 0 -> x *)
        | Sub (f, Float 0.) -> simp f
        (* f1 - f2 -> calcul (f1 - f2) *)
        | Sub (Float f1, Float f2) -> Float (f1 -. f2)
        (* f1 * x + x -> (f1 + 1) * x *)
        | Sub (f, g) when f = g -> Float 0.

        | Sub (f, g) -> Sub (simp f, simp g)

        (* 0 / x -> 0 *)
        | Div (Float 0., f) -> Float 0.
        (* x / 1 -> x *)
        | Div (f, Float 1.) -> simp f
        (* f1 / f2 -> calcul (f1 / f2) *)
        | Div (Float f1, Float f2) -> Float (f1 /. f2)
        (* x / x -> 1 *)
        | Div (f, g) when f = g -> Float 1.

        | Div (f, g) -> Div (simp f, simp g)

        (* 1 * x -> x *)
        | Mul (Float 1., f) -> simp f
        (* x * 1 -> x *)
        | Mul (f, Float 1.) -> simp f
        (* 0 * x -> 0 *)
        | Mul (Float 0., f) -> Float 0.
        (* x * 0 -> 0 *)
        | Mul (f, Float 0.) -> Float 0.
        (* f1 * f2 -> calcul (f1 * f2) *)
        | Mul (Float f1, Float f2) -> Float (f1 *. f2)

        (* x * x -> x ^ 2 *)
        | Mul (f, g) when f = g -> simp (Puis (simp f, Float 2.))
        (* x ^ a * x -> x ^ (a + 1) *)
        | Mul (Puis (f, g), h) when f = h -> Puis (simp f, simp (Add (simp g, Float 1.)))

        (* (f1 * x) * f2 -> (f1 * f2) * x *)
        | Mul (Mul (Float f1, f), Float f2) -> simp (Mul (Float (f1 *. f2), simp f))
        (* f1 * (f2 * x) -> (f1 * f2) * x *)
        | Mul (Float f1, Mul (Float f2, f)) -> simp (Mul (Float (f1 *. f2), simp f))
        (* (x * f1) * f2 -> (f1 * f2) * x *)
        | Mul (Mul (f, Float f1), Float f2) -> simp (Mul (Float (f1 *. f2), simp f))
        (* f1 * (x * f2) -> (f1 * f2) * x *)
        | Mul (Float f1, Mul (f, Float f2)) -> simp (Mul (Float (f1 *. f2), simp f))

        | Mul (f, g) -> Mul (simp f, simp g)

        (* x ^ 0 -> 1 *)
        | Puis (f, Float 0.) -> Float 1.
        (* 0 ^ x -> 0 *)
        | Puis (Float 0., f) -> Float 0.
        (* x ^ 1 -> x *)
        | Puis (f, Float 1.) -> simp f

        | Puis (f, g) -> Puis (simp f, simp g)

        | Ln f -> Ln (simp f)
        | Cos f -> Cos (simp f)
        | Sin f -> Sin (simp f)
        | Sqrt f -> Sqrt (simp f)
        | Exp f -> Exp (simp f)

这是我的问题：对于x * x + x * x的简单函数，此函数有效。 但是，如果我输入函数：2 + x * x-x * x，则不会进行任何简化。 结果是：2 + x ^ 2-x ^ 2

我不知道如何解决此问题，因为我已经三天了。

我希望一切都清楚了，有人可以给我一些提示！ 祝你有美好的一天！

Answer 1

问题有两个方面：

如果画出树，您将看到子树不相等。
您以自上而下的方式进行操作。 通常，应该从下到上进行简化（从高到低的优先级，例如2+x*x+x*x ==> 2+x^2+x^2 ==> 2+2x^2 ）

您的方程式就是这棵树：

- : formel = Sub (Add (Float 2., Mul (Var "x", Var "x")), Mul (Var "x", Var "x"))

让我们遵循执行顺序：

它匹配Sub (f, g) -> Sub (simp f, simp g)与
f = Add (Float 2., Mul (Var "x", Var "x"))

g = Mul (Var "x", Var "x")
从（1）开始执行simp f ，因此匹配Add (f, g) -> Add (simp f, simp g)
2.1。 它与Float f -> Float f匹配Float(2.)
2.2。 Mul (f, g) when f = g -> simp (Puis (simp f, Float 2.))它将Mul(Var("x"),Var("x"))与Mul (f, g) when f = g -> simp (Puis (simp f, Float 2.))
它继续在simp g上继续运行，因此Mul (f, g) when f = g -> simp (Puis (simp f, Float 2.))匹配Mul (f, g) when f = g -> simp (Puis (simp f, Float 2.))

这就是为什么您得到以下结果的原因：

Sub (Add (Float 2., Puis (Var "x", Float 2.)), Puis (Var "x", Float 2.))

（2 + x ^ 2-x ^ 2）

因为left（ 2 + x^2 ）和right（ x^2 ）子树不相等。

解决问题（1）

一种想法是添加加法规则的可交换属性，并将其转换为相同优先级的列表。 例如，

Sub(f,Add(g,h)) -> [Plus(f),Minus(g),Minus(h)]

这样，您可以识别相同的子树并消除它们。

解决问题（2）您需要基于运算符的优先级进行简化，例如x*x在x+x简化为2x之前变为x^2 。 这可以通过更改代码以多次运行来完成。 每次子树更改时，请在上层树上重新运行简化操作。

另一个想法是通过统一和替代技术将其存档。 我还没想通 但这确实令人信服。

在ocaml中简化计算机代数系统的方程式

问题描述

1 个解决方案

解决方案1
0 已采纳 2018-08-03 04:04:28

在ocaml中简化计算机代数系统的方程式

问题描述

1 个解决方案

解决方案1 0 已采纳 2018-08-03 04:04:28

解决方案1
0 已采纳 2018-08-03 04:04:28