コンピューターと人間-私たちがお互いを理解することはどれほど難しいか。実際、プログラミングプロセスは、マシンが理解できる言語で、マシンに必要なものを説明するものです。

はじめに

私の仕事では、また趣味として、数学計算に関連するコードを書くプロセスに関与しています。最後のタスクの1つは、データを計算、視覚化、およびいくつかの数式を最適化するときに、ユーザーが独自に入力して使用できるソフトウェアを作成することでした。そして、特別な数学関数のコードライブラリを絶えず補完する私の自然な怠andさと不本意を考慮して、考えが思い浮かびました-クレイジーな学生のアイデアを実装し、数式用のパーサーバイクを発明しないのはなぜですか？

もちろん、本発明のプロセスに着手する前に（再び、普遍的な怠inessを考慮して）、既存の実装をテーマにしたYandexとGoogleのかなり長いレイプがありました。そしてもちろん、彼らは非常に多く発見されました。しかし、残念ながら、特定の実装から達成したかったものは見つかりませんでした。検索条件は次のとおりです。

パーサーは、4.0より古い.NETの下で実装する必要があります。
すべての基本的な数学演算子（+、-、*、/、^など）を処理し、さまざまな種類の優先順位とブラケットを考慮に入れる必要があります。
メイン関数（sin、cosなど）を認識し、作成されたパーサーオブジェクトに独自の関数を追加して、（任意の数の入力変数に対して）値を計算するメソッドのデリゲートを示すことができます。
パーサーに既知の定数を使用し、それらを式の解析に使用されるリストに追加することができるはずです。
パラメータと変数を操作するメカニズムが必要です。これには、さまざまなタイプの変数が必要です。単に数値を格納するか、呼び出し時に外部コードが値を決定するイベントを発生させます。
機能的なメカニズムを実装する必要があります（最小-統合、シリーズの合計、および差別化）
文字列式の解析結果は、バイナリツリーオブジェクトモデルで表現する必要があります。
最も重要なことは、バイナリツリーがLinq.Expressionツリーにマップでき、それを.NETプラットフォーム自体の速度で計算を実行するデリゲートにコンパイルできることです。

自転車作りの目標

実際、自転車の発明の主な目標は、一連の数式をデリゲートにコンパイルして、値を計算するプロセスを高速化する可能性でした。

残念ながら、検索エンジンで作業するための私のわずかな能力、時間、労力、怠ofの欠如は、プロトタイプの検索で肯定的な結果をもたらさなかったため、熊手旅行に着手することにしました。

モデルと主なアイデア

オブジェクトモデルは、パーサークラスと数式クラスの2つのクラスで構成されます。内部では、さらに3つのクラスが使用されます：数学式ツリークラス、mat.expressionツリーの抽象ノードクラス、およびmat.expression文字列の論理要素のクラス-用語。さらに、関数、変数、関数のクラス、および関数、変数、および関数のコレクションがそれぞれ実装されます（これらは数学のクラスに埋め込まれます）。

発見、または解決策の最適化のふりをしていないが、問題の解決策にアプローチする試みであったアイデアは、mat.expression文字列の文字の初期シーケンスをいくつかの論理コンポーネントに分解することでした。型付けされた数式の論理ブロックの階層シーケンスを形成します。そして、それに基づいて、mat.expressionのツリーを構築します。

設計は、「どのように完成させて、使いやすく便利にしたいか？」というアイデアから始まりました。次のユースケースを実装したいと思いました。

パーサーオブジェクトが作成され、プレゼンテーションモデルのレベルまたはビジネスロジックのどこかに修正されます。それは構成されます：必要な定数がそれに追加され、その後機能する関数が定義されます。不明な関数および変数を処理するために、イベントサブスクライバーが追加されます。そして、パーサーはParce（string）メソッドの呼び出しを待っています。

メインのParce（）メソッドでは、マット式文字列が入力として渡され、その結果はマット式ツリーを含むマット式オブジェクトになります。

mat.expressionのオブジェクトには、その中にある関数、変数、および定数のコレクションが必要です。これらのオブジェクトの値を変更する可能性、およびその修正を目的として式ツリーに影響を与える可能性があるはずです。数式のオブジェクトには、（数式のツリーをトラバースすることにより）値を計算するメソッドが必要です。このメソッドは、入力変数のセットをパラメーターとして受け取り、結果として数値を生成します。

数式オブジェクトには、数式ツリーをSystem.Linq.Expressionオブジェクトに変換するメソッドが必要です。そして、Linq.Expressionメカニズムを使用してすぐにコンパイルされたデリゲートを取得するメソッド。

残念ながら、類似した何かの既製の実装も、そのようなパーサーの作成をある程度説明する方法も、どこにも説明されていません。

オブジェクトモデルの説明

パーサークラス

オブジェクトの作成（作成後）は、Parseメソッドの呼び出しから始まります。

パブリックMathExpression解析（文字列StrExpression）

/// <summary>   </summary> /// <param name="StrExpression">   </param> /// <returns> </returns> [NotNull] public MathExpression Parse([NotNull] string StrExpression) { Contract.Requires(!string.IsNullOrWhiteSpace(StrExpression)); Contract.Ensures(Contract.Result<MathExpression>() != null); StrPreprocessing(ref StrExpression); OnStringPreprocessing(ref StrExpression); var expression = new MathExpression(StrExpression, this); ProcessVariables(expression); ProcessFunctions(expression); return expression; }

契約を省略すると、彼の仕事の意味は、文字列の前処理、数式のコンストラクターの呼び出し、および変数と関数の分析のためのこの式の後処理に限定されます。

前処理には2つの段階があります。

文字列から余分な文字を削除するプライベートStrPreprocessingメソッド：

保護されたvoid StrPreprocessing（参照文字列Str）

 /// <summary>    </summary> /// <param name="Str"> </param> //     ,     protected virtual void StrPreprocessing([NotNull] ref string Str) { Contract.Requires(!string.IsNullOrEmpty(Str)); Contract.Ensures(!string.IsNullOrEmpty(Contract.ValueAtReturn(out Str))); Str = new string(Str.Where(f_ExcludeCharsSet.NotContains).ToArray()); }

パーサーユーザーが分析のために文字列を独立して準備できるように、文字列前処理イベントを生成するメソッド：

パブリックイベントEventHandler <EventArgs <string >> StringPreprocessing

 /// <summary>   </summary> public event EventHandler<EventArgs<string>> StringPreprocessing; /// <summary>    </summary> /// <param name="args"> ,   </param> protected virtual void OnStringPreprocessing([NotNull] EventArgs<string> args) { Contract.Requires(args != null); Contract.Requires(args.Argument != null); Contract.Requires(args.Argument != string.Empty); Contract.Ensures(args.Argument != null); Contract.Ensures(args.Argument != string.Empty); StringPreprocessing?.Invoke(this, args); } /// <summary>    </summary> /// <param name="StrExpression"> </param> private void OnStringPreprocessing([NotNull] ref string StrExpression) { Contract.Requires(!string.IsNullOrEmpty(StrExpression)); Contract.Ensures(Contract.ValueAtReturn(out StrExpression) != null); Contract.Ensures(Contract.ValueAtReturn(out StrExpression) != string.Empty); var args = new EventArgs<string>(StrExpression); OnStringPreprocessing(args); StrExpression = args.Argument; }

行のガベージがクリアされ、解析の準備が整うと、式のコンストラクターに渡されます。関数、定数、変数の定義を担当するパーサー自体も渡されます。

そのメンバーが言及されると、パーサークラスに戻ります。そして、...数学表現のクラス：

チャート

Parseメソッドからの呼び出しが渡されるコンストラクター：

内部MathExpression（文字列StrExpression、ExpressionParserパーサー）

 /// <summary>   </summary> /// <param name="StrExpression">  </param> /// <param name="Parser">  </param> internal MathExpression([NotNull] string StrExpression, [NotNull] ExpressionParser Parser) : this() { Contract.Requires(!string.IsNullOrEmpty(StrExpression)); Contract.Requires(Parser != null); Contract.Ensures(Tree != null); var terms = new BlockTerm(StrExpression); //     var root = terms.GetSubTree(Parser, this); //       f_ExpressionTree = new ExpressionTree(root); //      }

繰り返しますが、コントラクトブロックを省略すると、最初に、行に基づいて、式の用語の階層オブジェクト構造が作成されます。次に、最初のブロックから、mat.expressionのツリーのルートを取得するメソッドが呼び出されます。そして、それに基づいてツリーコンストラクターが機能します。

数式の分析の最初の段階では、文字列表現（文字のシーケンス）を論理ブロックのシーケンスに結合する必要があります。それらのいくつかは、互いに再帰的にネストできます。

式用語クラスの階層

行は4種類の用語に分かれています。

BlockTerm-用語の配列を含む用語。
StringTerm-文字列値を含む用語
CharTerm-通常の文字列に関連付けることができない1文字を含む用語。
NumberTermは、整数を含む用語です。

したがって、最初は行全体が1つのブロック用語として表され、その中に構成要素が含まれます。

public BlockTerm（文字列Str）

 /// <summary>   </summary> /// <param name="Str">  </param> public BlockTerm(string Str) : this("", Str, "") { } /// <summary>  </summary> /// <param name="OpenBracket"> </param> /// <param name="Str">  </param> /// <param name="CloseBracket"> </param> public BlockTerm([NotNull] string OpenBracket, [NotNull] string Str, [NotNull] string CloseBracket) : base(string.Format("{0}{2}{1}", OpenBracket ?? "", CloseBracket ?? "", Str)) { Contract.Requires(!string.IsNullOrEmpty(Str)); f_OpenBracket = OpenBracket; f_CloseBracket = CloseBracket; f_Terms = GetTerms(Str); }

基本的なテルマクラス：

抽象クラスTerm {...}

 /// <summary>  </summary> abstract class Term { /// <summary> </summary> protected string f_Value; /// <summary>   </summary> /// <param name="Value"> </param> protected Term(string Value) { f_Value = Value; } /// <summary>       </summary> /// <param name="Parser">  </param> /// <param name="Expression"> </param> /// <returns>  .,     </returns> [NotNull] public abstract ExpressionTreeNode GetSubTree([NotNull] ExpressionParser Parser, [NotNull] MathExpression Expression); /// <summary>   .</summary> /// <returns>   .</returns> public override string ToString() => f_Value; }

部分文字列の構成要素への内訳は、GetTermsメソッドによって実行されます。

private static Term [] GetTerms（文字列Str）

 /// <summary>      </summary> /// <param name="Str">   </param> /// <returns>   </returns> [CanBeNull] private static Term[] GetTerms([CanBeNull] string Str) { if(Str == null) return null; if(Str.Length == 0) return new Term[0]; var pos = 0; var len = Str.Length; var result = new List<Term>(); while(pos < len) { var c = Str[pos]; if(char.IsLetter(c) || c == '∫') { Term value = new StringTerm(GetNameString(Str, ref pos)); if(pos < len) switch(Str[pos]) { case '(': { var blokStr = Str.GetBracketText(ref pos); var block = new BlockTerm("(", blokStr, ")"); value = new FunctionTerm((StringTerm)value, block); } break; case '[': { var blokStr = Str.GetBracketText(ref pos, "[", "]"); var block = new BlockTerm("[", blokStr, "]"); value = new FunctionTerm((StringTerm)value, block); } break; case '{': { var blokStr = Str.GetBracketText(ref pos, "{", "}"); var block = new BlockTerm("{", blokStr, "}"); value = new FunctionTerm((StringTerm)value, block); } break; } if(pos < len && Str[pos] == '{') value = new FunctionalTerm ( (FunctionTerm)value, new BlockTerm("{", Str.GetBracketText(ref pos, "{", "}"), "}") ); result.Add(value); } else if(char.IsDigit(c)) result.Add(new NumberTerm(GetNumberString(Str, ref pos))); else switch(c) { case '(': { var blokStr = Str.GetBracketText(ref pos); var block = new BlockTerm("(", blokStr, ")"); result.Add(block); } break; case '[': { var blokStr = Str.GetBracketText(ref pos, "[", "]"); var block = new BlockTerm("[", blokStr, "]"); result.Add(block); } break; case '{': { var blokStr = Str.GetBracketText(ref pos, "{", "}"); var block = new BlockTerm("{", blokStr, "}"); result.Add(block); } break; default: result.Add(new CharTerm(Str[pos++])); break; } } return result.ToArray(); }

このメソッドは、空の入力行とゼロ長をチェックすることから始まります。その後、行内の分析されたシンボルの現在の位置とその長さが固定され、その後、現在の位置のシンボルは行の終わりに達するまでサイクルで考慮されます。

-文字または整数の記号の場合、GetNameStringメソッドを使用して名前をキャプチャしようとします。

プライベート静的文字列GetNameString（文字列Str、ref int pos）

 /// <summary>   </summary> /// <param name="Str"> </param> /// <param name="pos">  </param> /// <returns> </returns> private static string GetNameString([NotNull] string Str, ref int pos) { Contract.Requires(!string.IsNullOrEmpty(Str)); Contract.Ensures(Contract.ValueAtReturn(out pos) >= 0); Contract.Ensures(Contract.ValueAtReturn(out pos) < Str.Length); var result = ""; var L = Str.Length; var i = pos; while(i < L && (char.IsLetter(Str[i]) || Str[i] == '∫')) result += Str[i++]; if(i == L || !char.IsDigit(Str[i])) { pos = i; return result; } while(i < L && char.IsDigit(Str[i])) result += Str[i++]; pos += result.Length; return result; }

その後、現在の文字に開始ブラケットがあるかどうかがチェックされます。ブラケットの1つが見つかった場合、ネストされたブロックが行から抽出され、開始ブラケットと対応する終了ブラケットによって制限されます。この方法で作成されたブロック用語は、機能用語のコンストラクターに配置され、前に設定された関数名が示されます。

開き括弧と閉じ括弧で制限された部分文字列は、拡張メソッドによって文字列から選択されます。

public static string GetBracketText（この文字列Str、ref int Offset、文字列Open、文字列Close）

 /// <summary> ///  ,            /// </summary> /// <param name="Str"> </param> /// <param name="Offset"> ///       -         /// </param> /// <param name="Open">  </param> /// <param name="Close">  </param> /// <returns>,       </returns> /// <exception cref="FormatException"> ///      ,        ///       /// </exception> public static string GetBracketText(this string Str, ref int Offset, string Open = "(", string Close = ")") { var Start = Str.IndexOf(Open, Offset, StringComparison.Ordinal); if(Start == -1) return null; var Stop = Str.IndexOf(Close, Start + 1, StringComparison.Ordinal); if(Stop == -1) throw new FormatException(); var start = Start; do { start = Str.IndexOf(Open, start + 1, StringComparison.Ordinal); if(start != -1 && start < Stop) Stop = Str.IndexOf(Close, Stop + 1, StringComparison.Ordinal); } while(start != -1 && start < Stop); if(Stop == -1 || Stop < Start) throw new FormatException(); Offset = Stop + Close.Length; Start += Open.Length; return Str.Substring(Start, Stop - Start); }

最初に、開始文字と終了文字の最初の出現のインデックスが決定されます。最初の文字が見つからない場合は、voidを返します。終了文字が見つからない場合、これはフォーマットエラーです。

この方法の考え方は、行の先頭と末尾のパターンを順番に循環検索することです。次のオープニングキャラクターを見つけようとしています。見つかって、終了文字の前にある場合は、終了文字のインデックスを更新する必要があります。サイクルは、開始文字の前にない終了文字があるまで続きます。

メソッドの結果は、開始文字と終了文字の間にあるサブストリングです。

形成された機能用語の後に開始中括弧が見つかった場合、これは機能の本体を開始します。ブロック内の中括弧の内容を選択し、term-functionalを作成し、term-functionを示します。このコンテキストでは、関数の名前とそのパラメーターが含まれ、本体は中括弧内のブロックになります。

括弧が見つからなかった場合、見つかった名前はリテラル（将来の変数...または定数）です。

-文字列の次の文字が数字の場合、整数が始まります。数字のみを含む部分文字列を選択します。

プライベート静的文字列GetNumberString（文字列Str、ref int pos）

 /// <summary>  </summary> /// <param name="Str"> </param> /// <param name="pos">   </param> /// <returns>  </returns> private static string GetNumberString([NotNull] string Str, ref int pos) { Contract.Requires(!string.IsNullOrEmpty(Str)); Contract.Ensures(Contract.ValueAtReturn(out pos) >= 0); Contract.Ensures(Contract.ValueAtReturn(out pos) < Str.Length); var p = pos; var l = Str.Length; while(p < l && !char.IsDigit(Str, p)) p++; if(p >= l) return null; var start = p; while(p < l && char.IsDigit(Str, p)) p++; pos = p; return Str.Substring(start, p - start); }

このメソッドの結果-数字を含む文字列-は、整数項のコンストラクターに分類されます。

-行の次の文字が開き括弧の場合、ブロックが始まります。 GetBracketText拡張メソッドでそのサブストリングを選択します。

-次の文字がブラケットではない場合、これはシンボル用語に変わる未定義の文字です。

作成されたすべての用語は最初にリストから収集され、配列として返されます。

他のすべての用語のコンストラクターはそれほど面白くありません。それらは、結果のパラメーターを内部フィールドに格納するだけです（おそらく型変換を使用）。

その後、文字列は、互いに埋め込まれた異なるタイプの用語のシーケンスの論理的な階層構造に変換されます。このシーケンスから、数式の二分木が再帰的に構築されます。

ツリーの基礎は、マットのツリーノードの基本クラスです。

クラス階層

各ノードは、左のサブツリーのルートノードと右のサブツリーのルートノードへのリンク、およびその祖先へのリンクを格納するクラスです。ツリーノードの抽象クラスは、祖先/子孫のノード、トラバーサルメソッド、現在のノードに関連付けられているノードの列挙を取得できる機能インデクサー、このノードに（サブツリーのルートとして）既知の変数、関数などを取得するための再帰メソッドにアクセスするためのインターフェイスを提供します。また、ノードの基本クラスは、多くの計算可能なプロパティを提供します：サイン-ノードが左/右サブツリーであるかどうか、ノードがルートであるかどうか、ツリールートへのリンク、ツリールートから現在のノードへのシンボリックパス、および祖先イテレータ。

木の結び目

このクラスのコードにより、ツリー要素を使用した基本的な操作が可能になり、それらを置換、再配置、トラバース、およびアクセスできます。必要に応じて個別のメソッドを提供します。全文は多くのスペースを占有します。プロジェクトソースから表示/コピーできます。

ツリーのすべてのノードは、計算可能または解析で使用できます。

解析ノードには、文字列ノード、文字ノード、間隔値ノードが含まれます。これらは、間隔を指定する必要がある統合機能など、ツリー内の特定のメタ構造を補完するために必要です。

計算可能なノードは、結果のツリー構造の主要なノードです。それらは、数式で記述できるすべての要素を表します。

これらには以下が含まれます。

ComputedBracketNode-ブラケットのブロックを表します
ValueNodeは、値ノードを表す抽象クラスです。彼の相続人：

-ConstValueNode-数値ノード

-VariableValueNode-変数ノード（pi、e、...などの定数）
FunctionNode-関数オブジェクトを表すノード
FunctionalNode-機能オブジェクトを表すノード
Node演算子は、演算子ノードの抽象クラスです。彼の相続人

-最も単純な数学演算子+、-、*、/、^;

-論理演算子==、！、>、<、&&、||;

-条件「<論理演算子の演算結果>？」の演算子そして、選択演算子「<option_1>：<option_2>」

-関数の引数へのアクセスを実装する演算子と、関数の引数の名前にアクセスするために使用されるステートメント。

ツリー構築プロセス

用語クラスは抽象メソッドGetSubTreeを宣言します。これにより、任意の用語からそれによって記述されたサブツリーを取得できます。ツリーの構築プロセスは、ソース文字列から生成されたブロック用語でこのメソッドを呼び出すことから始まります。

パブリックオーバーライドExpressionTreeNode GetSubTree（ExpressionParserパーサー、MathExpression Expression）

 /// <summary>   </summary> /// <param name="Parser"> </param> /// <param name="Expression"> </param> /// <returns> </returns> public override ExpressionTreeNode GetSubTree(ExpressionParser Parser, MathExpression Expression) { Contract.Requires(Parser != null); Contract.Requires(Expression != null); Contract.Ensures(Contract.Result<ExpressionTreeNode>() != null); var separator = Parser.ExpressionSeparator; //  -  //      ,  - //             var roots = Terms .Split(t => t is CharTerm && ((CharTerm)t).Value == separator) .Select(g => Parser.GetRoot(g, Expression)).ToArray(); if(roots.Length == 1) return roots[0]; //     ,    //     ExpressionTreeNode argument = null; //     for(var i = 0; i < roots.Length; i++) //      { var root = roots[i]; ExpressionTreeNode arg; //     if(root is FunctionArgumentNode) // -   arg = root; // --     else if(root is FunctionArgumentNameNode) // -    // --      arg = new FunctionArgumentNode(root as FunctionArgumentNameNode); else if(root is VariantOperatorNode && root.Left is VariableValueNode) arg = new FunctionArgumentNode(((VariableValueNode)root.Left).Name, root.Right); else // -     arg = new FunctionArgumentNode("", root); // --      if(argument == null) argument = arg; //     ,    ,   else //  argument = argument.Right = arg; //        } //     ,  -    -   if(argument == null) throw new FormatException("   "); return argument.Root; //    }

このメソッドは、渡されたオブジェクトから、ブロック内の式を表すシンボルを抽出します。デフォルトの区切り文字は「;」です。 -セミコロン。

次に、Linqシーケンスでは、ネストされた用語の配列全体が、セパレータ（式の区切り文字を含むシンボリック用語）によってサブ配列に分割されます。これは、Split拡張メソッドが担当します。

public static T [] [] Split <T>（このT []配列、Func <T、bool>スプリッター）

 /// <summary>      </summary> /// <typeparam name="T">  </typeparam> /// <param name="array"> </param> /// <param name="Splitter">,  ,     </param> /// <returns> ///     ,     . ///      . /// </returns> [NotNull] public static T[][] Split<T>([NotNull] this T[] array, [NotNull] Func<T, bool> Splitter) { Contract.Requires(array != null); Contract.Requires(Splitter != null); Contract.Ensures(Contract.Result<T[][]>() != null); var result = new List<T[]>(array.Length); var aggregator = new List<T>(array.Length); for(var i = 0; i < array.Length; i++) { var value = array[i]; if(Splitter(value) && aggregator.Count != 0) { result.Add(aggregator.ToArray()); aggregator.Clear(); } else aggregator.Add(value); } if(aggregator.Count != 0) result.Add(aggregator.ToArray()); return result.ToArray(); }

用語のサブ配列ごとに、このグループの用語のツリーのルートを決定するように設計されたGetRootパーサーメソッドが呼び出されます。次に、見つかったすべてのルートが配列に結合されます。

GetRootメソッド：

内部ExpressionTreeNode GetRoot（用語[]グループ、MathExpression MathExpression）

 /// <summary>        </summary> /// <param name="Group">   </param> /// <param name="MathExpression">   </param> /// <returns>  .</returns> internal ExpressionTreeNode GetRoot([NotNull] Term[] Group, [NotNull] MathExpression MathExpression) { Contract.Requires(Group != null); Contract.Requires(MathExpression != null); Contract.Ensures(Contract.Result<ExpressionTreeNode>() != null); //       ExpressionTreeNode Last = null; for(var i = 0; i < Group.Length; i++) //       { var node = Group[i].GetSubTree(this, MathExpression); //       //    ... if(Group[i] is NumberTerm) // ...  ,  { //...                if(i + 2 < Group.Length && NumberTerm.TryAddFractionPart(ref node, Group[i + 1], DecimalSeparator, Group[i + 2])) i += 2; //...      . } else if(Group[i] is BlockTerm) //...   ( ) node = new ComputedBracketNode( //    -    new Bracket( // : (((BlockTerm)Group[i]).OpenBracket), //     ((BlockTerm)Group[i]).CloseBracket), //     node); //   //       Combine(Last, Last = node); //       if(Last.IsRoot && Last is VariantOperatorNode && Last.Left is VariableValueNode) Last = new FunctionArgumentNameNode(((VariableValueNode)Last.Left).Name); OnNewNodeAdded(ref Last); } //      ,     if(Last == null) throw new FormatException(); return Last.Root; //      }

ここでは、式の用語の入力配列が順次スキャンされます。式の連続する各項から、そのツリーのルートを抽出します（ここで再帰が発生します）。次に、以下を確認する必要があります。-

現在の項が整数で、配列の最後から少なくとも3番目の場合、現在のノードに小数部分を追加しようとします。

public static bool TryAddFractionPart（ref ExpressionTreeNodeノード、Term SeparatorTerm、char DecimalSeparator、Term FrationPartTerm）

 /// <summary>    </summary> /// <param name="node"> </param> /// <param name="SeparatorTerm"> </param> /// <param name="DecimalSeparator">    </param> /// <param name="FrationPartTerm">    </param> /// <returns>,    . ,        </returns> public static bool TryAddFractionPart(ref ExpressionTreeNode node, Term SeparatorTerm, char DecimalSeparator, Term FrationPartTerm) { var value = node as ConstValueNode; if(value == null) throw new ArgumentException("   "); var separator = SeparatorTerm as CharTerm; if(separator == null || separator.Value != DecimalSeparator) return false; var fraction = FrationPartTerm as NumberTerm; if(fraction == null) return false; var v_value = fraction.Value; if(v_value == 0) return true; node = new ConstValueNode(value.Value + v_value / Math.Pow(10, Math.Truncate(Math.Log10(v_value)) + 1)); return true; }

このメソッドは、10進数の整数部分と小数部分の区切り文字、および現在の用語に続く2つの用語を示します。2番目の用語がシンボリックで区切り文字を含み、3番目が数値である場合、ノードは新しい定数値ノードに置き換えられます-2

番目のチェックは、現在の用語がブロックである場合、ブロックブロックノードが形成されます

チェックが完了すると、前のサイクルで作成されたノードと現在のサイクルを組み合わせたメソッドが実行されます。

public virtual void Combine（ExpressionTreeNode Last、ExpressionTreeNode Node）

 /// <summary>     </summary> /// <param name="Last">   (   )</param> /// <param name="Node"> ,     </param> // ReSharper disable once CyclomaticComplexity public virtual void Combine([CanBeNull] ExpressionTreeNode Last, [NotNull] ExpressionTreeNode Node) { Contract.Requires(Node != null); if(Last == null) return; //      ,  if(Node is CharNode) //    -  ,  { Last.LastRightChild = Node; //       return; } var operator_node = Node as OperatorNode; //      - if(operator_node != null) //     ... { //    : //         //            var parent_operator = Last as OperatorNode ?? Last.Parent as OperatorNode; if(parent_operator != null) //      - (   )...  { //           -   // op <-     // | // op // / \ // null ? if(parent_operator.Left == null && parent_operator.Parent is OperatorNode) parent_operator = (OperatorNode)parent_operator.Parent; if(parent_operator.Left == null) //      ... operator_node.Left = parent_operator; //         else if(parent_operator.Right == null) //      parent_operator.Right = Node; //       else //     { var priority = operator_node.Priority; //     //     ,     if(priority <= parent_operator.Priority) { //          parent_operator = (OperatorNode)parent_operator.Parents //            .TakeWhile(n => n is OperatorNode && priority <= ((OperatorNode)n).Priority) //     .LastOrDefault() ?? parent_operator; //    ,     //            if(parent_operator.IsRoot) //    -   //       ,      if(priority <= parent_operator.Priority) //       operator_node.Left = parent_operator; else //       { var parent = parent_operator.Parent; //       parent.Right = Node; //        operator_node.Left = parent_operator;//       } } else //       { //          parent_operator = (OperatorNode)parent_operator.RightNodes //              .TakeWhile(n => n is OperatorNode && n.Left != null && ((OperatorNode)n).Priority < priority) //     .LastOrDefault() ?? parent_operator; //    ,     //            var right = parent_operator.Right; //      parent_operator.Right = Node; //        operator_node.Left = right; //         } } } else //       { var parent = Last.Parent; var is_left = Last.IsLeftSubtree; var is_right = Last.IsRightSubtree; operator_node.Left = Last; //       if(is_left) parent.Left = operator_node; else if(is_right) parent.Right = operator_node; } return; //  } //       if(Last is OperatorNode) //      { Last.Right = Node; //       return; //  } //          //    ,        -  if(Last is ConstValueNode || (Last is ComputedBracketNode && Node is ComputedBracketNode)) { //      var parent = Last.Parent; if(parent != null) //    //            parent.Right = new MultiplicationOperatorNode(Last, Node); else //       //   -     ,      new MultiplicationOperatorNode(Last, Node); return; // . } Last.Right = Node; }

これは中心的な方法の1つです。作成された数式ツリーのロジックに従って、演算子ノード（それらの優先順位）を考慮して、既存のノードに新しいノードをアタッチします。もちろん、メソッドはコードのサイズのためにリファクタリングを必要とします。彼の作品の論理は、コードのコメントに反映されています。

2つのノードの組み合わせが完了すると、最後のチェックが実行されます。処理されたノードがツリーのルートであり、ノードが選択肢のノードであり、この場合ノード変数<Variable>：<option_2>が左サブツリーにある場合、引数引数<argument_nameのノードと見なされる必要があります>：<argument_value>。この場合、引数の名前は変数名になります。

反復が完了すると、パーサーオブジェクトでNewNodeAddedイベントが生成され、作成されたノードはユーザーによる外部処理のために渡されます。この場合、ノードは参照によって渡されるため、作成されたツリーを完全にオーバーライドする可能性があります。

パーサーによって用語のグループに対してサブツリーが作成され、ブロック用語のGetSubTreeメソッドで、そのようなサブツリーのすべてのルートが配列に結合された後、メソッドはチェックします。

配列に要素が1つしか含まれていない場合、結果として返されます（これは簡単なケースです）
多くのルートがある場合、それらのそれぞれはFunctionArgumentNode関数の引数のノード（右側のサブツリー内）にパックされ、次の引数は左側のサブツリーにしがみつきます。

式ツリーの構造

したがって、生成されたツリーは次のルールを満たします。

(, ) ( )
. .
, . ;
— -, -.
. ( ).

関数と機能自体は、別々のオブジェクトに割り当てられます。

ツリーが構築されます。構築プロセス中に、変数と関数のノードが作成されました。そのような各ノードは、対応するタイプのノードのコンストラクターへの直接呼び出しによって、対応する用語によって作成されました。

クラスStringTerm：用語{...}

 /// <summary>  </summary> class StringTerm : Term { /// <summary>  </summary> [NotNull] public string Name => f_Value; /// <summary>  </summary> /// <param name="Name">  </param> public StringTerm([NotNull] string Name) : base(Name) { Contract.Requires(!string.IsNullOrEmpty(Name)); } /// <summary> ,   -</summary> /// <param name="Parser"></param> /// <param name="Expression"> </param> /// <returns>   ,   Expression.Variable[Name]</returns> public override ExpressionTreeNode GetSubTree(ExpressionParser Parser, MathExpression Expression) => new VariableValueNode(Expression.Variable[Name]); } /// <summary>  </summary> sealed class FunctionalTerm : FunctionTerm { /// <summary> </summary> [NotNull] public BlockTerm Parameters { get; set; } /// <summary>   </summary> /// <param name="Header"> </param> /// <param name="Body"> </param> public FunctionalTerm([NotNull] FunctionTerm Header, [NotNull] BlockTerm Body) : base(Header.Name, Body) { Contract.Requires(Header != null); Contract.Requires(Body != null); Parameters = Header.Block; } /// <summary>   </summary> /// <param name="Parser"></param> /// <param name="Expression"> </param> /// <returns>  </returns> public override ExpressionTreeNode GetSubTree(ExpressionParser Parser, MathExpression Expression) => new FunctionalNode(this, Parser, Expression); public override string ToString() => $"{Name}{Parameters}{Block}"; }

同時に、ノードを作成するとき、式には、目的の変数オブジェクト/関数を名前で抽出するための変数/関数のコレクションが必要です。

内部FunctionNode（FunctionTerm用語、ExpressionParserパーサー、MathExpression式）

 /// <summary>   </summary> /// <param name="Term"> </param> /// <param name="Parser"> </param> /// <param name="Expression"> </param> internal FunctionNode(FunctionTerm Term, ExpressionParser Parser, MathExpression Expression) : this(Term.Name) { var arg = Term.Block.GetSubTree(Parser, Expression); if(!(arg is FunctionArgumentNode)) if(arg is FunctionArgumentNameNode) arg = new FunctionArgumentNode((FunctionArgumentNameNode)arg); else if(arg is VariableValueNode) arg = new FunctionArgumentNode(null, arg); else if(arg is VariantOperatorNode && arg.Left is VariableValueNode) arg = new FunctionArgumentNode(((VariableValueNode)arg.Left).Name, arg.Right); else arg = new FunctionArgumentNode(null, arg); Right = arg; // -   Function = Expression.Functions[Name, ArgumentsNames]; }

数式オブジェクトでツリーが作成された後、変数と関数のコレクションには使用されたオブジェクトのリストが含まれます。しかし、それらの意味は空です。一部の変数は、パーサーに既知の定数として分類する必要があります（適切なコレクションに転送します。関数オブジェクトは、それらを実装するデリゲートによって定義する必要があります。

ツリーの初期化

数式の「生の」ツリーを作成した後、変数と関数の値を入力する必要があります。パーサーのParseメソッドは、ProcessVariablesとProcessFunctionsの2つのメソッドを順番に呼び出して、作成された「生の」ツリーを渡します。

変数処理方法：

内部void ProcessVariables（MathExpression式）

 /// <summary> </summary> /// <param name="Expression">  </param> internal void ProcessVariables([NotNull] MathExpression Expression) { Contract.Requires(Expression != null); var tree_vars = Expression.Tree.Root.GetVariables().ToArray(); Expression.Variable .Where(v => !tree_vars.Contains(v)) .ToArray() .Foreach(v => Expression.Variable.Remove(v)); foreach(var variable in Expression.Variable.ToArray()) { if(f_Constans.ContainsKey(variable.Name)) { Expression.Variable.MoveToConstCollection(variable); variable.Value = f_Constans[variable.Name]; } OnVariableProcessing(variable); } }

そのタスクは、ツリーを一周し、すべての変数ノードを見つけて、それらで使用されている変数オブジェクトを抽出することです。その後、ツリーで使用されていないすべてのものを数式の変数のコレクションから削除する必要があります。

その後、ツリー内の各変数について、その名前が既知のパーサー定数のコレクションに含まれているかどうかがチェックされます。そうである場合、式の変数のコレクションから削除され、式の定数のコレクションに入力され、パーサーに既知の値で初期化され、定数であるというフラグが設定されます。

その後、パーサーで新しい変数を検出するイベントが発生します。このイベントを処理するとき、パーサーユーザーはこの変数の値をオーバーライドするか、変数オブジェクト自体を変更できます。

2番目のProcessFunctionsメソッドは、式に既知の関数でデリゲートを埋めます。

内部void ProcessFunctions（MathExpression式）

 /// <summary> </summary> /// <param name="Expression">  </param> [SuppressMessage("ReSharper", "CyclomaticComplexity")] internal void ProcessFunctions([NotNull] MathExpression Expression) { Contract.Requires(Expression != null); foreach(var function in Expression.Functions) switch(function.Name) { case "Sin": case "SIN": case "sin": if(function.Arguments.Length != 1) goto default; function.Delegate = new Func<double, double>(Math.Sin); break; case "COS": case "Cos": case "cos": if(function.Arguments.Length != 1) goto default; function.Delegate = new Func<double, double>(Math.Cos); break; case "TAN": case "Tan": case "tan": case "tn": if(function.Arguments.Length != 1) goto default; function.Delegate = new Func<double, double>(Math.Tan); break; case "ATAN": case "ATan": case "Atan": case "atan": case "atn": case "Atn": if(function.Arguments.Length == 1) function.Delegate = new Func<double, double>(Math.Atan); else if(function.Arguments.Length == 2) function.Delegate = new Func<double, double, double>(Math.Atan2); else goto default; break; case "Atan2": case "atan2": if(function.Arguments.Length != 2) goto default; function.Delegate = new Func<double, double, double>(Math.Atan2); break; case "CTG": case "Ctg": case "ctg": if(function.Arguments.Length != 1) goto default; function.Delegate = new Func<double, double>(x => 1 / Math.Tan(x)); break; case "Sign": case "sign": if(function.Arguments.Length != 1) goto default; function.Delegate = new Func<double, double>(x => Math.Sign(x)); break; case "Abs": case "abs": if(function.Arguments.Length != 1) goto default; function.Delegate = new Func<double, double>(Math.Abs); break; case "Exp": case "EXP": case "exp": if(function.Arguments.Length != 1) goto default; function.Delegate = new Func<double, double>(Math.Exp); break; case "Sqrt": case "SQRT": case "√": case "sqrt": if(function.Arguments.Length != 1) goto default; function.Delegate = new Func<double, double>(Math.Sqrt); break; case "log10": case "Log10": case "LOG10": case "lg": case "Lg": case "LG": if(function.Arguments.Length != 1) goto default; function.Delegate = new Func<double, double>(Math.Log10); break; case "loge": case "Loge": case "LOGe": case "ln": case "Ln": case "LN": if(function.Arguments.Length != 1) goto default; function.Delegate = new Func<double, double>(Math.Log); break; case "log": case "Log": case "LOG": if(function.Arguments.Length != 2) goto default; function.Delegate = new Func<double, double, double>(Math.Log); break; default: var f = OnFunctionFind(function.Name, function.Arguments); if(f == null) throw new NotSupportedException($"  {function.Name}  "); function.Delegate = f; break; } }

関数名がcase演算子のバリアントに含まれている場合、必要な関数が引数の数と一致すると、デリゲートがそれに割り当てられ、その値が計算されます。関数が定義されていない場合、デリゲートは未知の関数検出イベントの生成の結果として定義されます。この場合、ユーザーは、引数の名前と数（および名前）によって、このイベントへの応答で必要なデリゲートを決定できます。

これで、数式の生成が完了しました。

使用する

私たちの仕事は、関数A * cos（2 * x）/ pi + G（x / 2）をAと+ 1で除算した積分を計算することであると仮定します。たとえば、Aが5の場合、0.05の増分で積分をとる必要があります。

 var parser = new ExpressionParser(); parser .FindFunction += (s, e) => { if(e.SignatureEqual(name: "G", ArgumentsCount: 1)) e.Function = new Func<double, double>(x => 2 * Math.Cos(x)); }; var expr = parser.Parse(@"Int[x=-10..10;dx=0.05]{A*cos(2x) + G(x/2)}/A + 1"); expr.Variable["A"] = 5; var y = expr.Compute(); //y = 0.30928806858920344 var f = expr.Compile(); var y2 = f(); //y = 0.30928806858920344

おわりに

記事の結果のボリュームを考えると、ここにピリオドではなくセミコロンを入れました。上記の結果、次のことが可能になりました。

問題を解決する方法の一般的なアイデアを入手してください。
数式のパーサー、数式自体、およびそのツリーのオブジェクトモデルを形成するには、
数式を論理コンポーネントに解析するための効果的な方法を作成します。
括弧の使用の特殊性、演算子の優先順位、および特別な構成（関数）を考慮して、数式のツリーを構築するための効果的な方法を作成します。
イベントシステムに基づいて、パーサーが入力データを処理するさまざまな段階を制御します。
機能を拡張する機能を追加します。

この記事では説明できなかったもの：

変数の論理（それらの準備とその後の置換のタイプと方法）;
数式の作業に関与する変数、定数、関数のコレクションの構造。
ツリーを走査して数式の値を計算する方法。
mat.expressionのツリーをデリゲートにコンパイルするためのメソッド。

パーサー自体の実装でこれまでに失敗したもの：

数式のツリーを最適化するメソッドを実装します。
多くの場所から松葉杖を取り外します。
入力データがマットの形式に準拠しているかどうかのチェックを追加します。
実際に、この形式の境界を概説してください。
単体テストでコードカバレッジを増やします。
分析の段階と計算の段階の両方のパフォーマンスの比較研究を実施します。

一般に、このコードの作業には残念ながら背景文字があり、数年続いていますが、この段階で割り当てられたタスクは既に解決しています。現在の形では彼を生産に入れることは不可能です。

完全なソースコードはここで見つけることができます。

C＃Math Parser-アマチュアエクスペリエンス