非常好的一篇文章，Graph of Function

悠悠 2022-08-13 12:44 185阅读 0赞

原文：[http://www.codeproject.com/Articles/713686/Graph-of-Function][http_www.codeproject.com_Articles_713686_Graph-of-Function]

*  [Download GraphOfFunction-noexe.zip - 245.2 KB][]
 *  [Download GraphOfFunction.zip - 404.5 KB][]

## Introduction ##

My program allows you to build a graph of a function given a string. In the program the user himself defines the boundaries within which there is a graph of the construction and function of the color line. To change the priority operations can use parentheses. The program examines the construction schedule affiliation argument domain of the function. Therefore, the graph is constructed only in locations that are the domain of the function. You can build any number of graphics functions, setting for each color display. You can change and delete functions are introduced.

## Windows ##

The main program window.

![home_window.png][]

Window entry functions.

![function_window.png][]

## Architecture ##

The program works in the following way change a character string, a list of tokens, syntax tree. Character string is a collection of some symbols that represent operations, functions, numbers, parentheses, variables x and constants pi and e token . List of tokens is a list of instances of classes that implement the interface `Isintahnode`. Syntax tree is a tree whose nodes are operations, functions, numbers, constants and variables are in accordance with the priority of their implementation.

![architecture.png][]

Graph drawing takes place on the panel using the methods of class Graphics.

## Using the code ##

Interface `ISyntaxNode` describes the behavior of token. Method `GetResult` returns result for this token. Method `IsDomainOfFunction` checks whether the value of x belongs to the domain of definition of the token. Method `ToStringValue` returns the symbol for the token.

![minus.gif][]  Collapse  |  [Copy Code][]

public interface ISyntaxNode
    {
        string ToStringValue();
        double GetResult(double x);
        bool IsDomainOfFunction(double x);
    }

Class Function that inherits the interface `ISyntaxNode`.

![minus.gif][]  Collapse  |  [Copy Code][]

abstract class Function: ISyntaxNode
    {
        private ISyntaxNode x;
        public Function()
        {
        }
    
        public Function(ISyntaxNode x)
        {
            this.x = x;
        }
        public  ISyntaxNode GetX()
        {
            return x;
        }
    
        public void SetX(ISyntaxNode x)
        {
            this.x = x;
        }
    
        public abstract double GetResult(double x);
        public abstract bool IsDomainOfFunction(double x);
        public abstract string ToStringValue();
    
    }

Class `Sin` that inherits from the class `Function` and implements the abstract methods.

![minus.gif][]  Collapse  |  [Copy Code][]

class Sin: Function
    {
        public Sin(): base()
        {
        }
    
        public Sin(ISyntaxNode x): base (x)
        {
        }
    
        public override double GetResult(double x)
        {
            return Math.Sin(GetX().GetResult(x));
        }
    
        public override bool IsDomainOfFunction(double x)
        {
            return GetX().IsDomainOfFunction(x);
        }
    
        public override string ToStringValue()
        {
            return "sin";
        }
    }

Attributes of the class `SyntaxTree` that performs build syntax tree.

`listOperations` - is a list conventional signs operations and functions that support the program.

`listBynaryOperations` - is a list conventional signs binary operations that support the program.

`listUnaryOperations` - is a list conventional signs unary operations that support the program.

`listFunctions` - is a list conventional signs functions that support the program.

`root` - is the root of syntax trees.

![minus.gif][]  Collapse  |  [Copy Code][]

static List<string> listOperations = new List<string>(new string[] { "+", "-", "*", "/", "--", "^", "sin", "cos", "tan", "ctg", "log", "abs"});
    static List<string> listBinaryOperations = new List<string>(new string[] { "+", "-", "*", "/", "^"});
    static List<string> listUnaryOperations = new List<string>(new string[] {
      "--" });
    static List<string> listFunctions = new List<string>(new string[] { "sin", "cos", "tan", "ctg", "log", "abs" });
    private ISyntaxNode root;

Method `BuildSyntaxTree` that performs build syntax tree. Method takes one parameter, which contains a list of tokens and return operations or functions with the lowest priority.

![minus.gif][]  Collapse  |  [Copy Code][]

private ISyntaxNode BuildSyntaxTree(List<ISyntaxNode> listNode)
    {
        DeleteExcessiveBrackets(listNode);
        if (listNode.Count == 1)  return listNode[0];
    
        int position;
        ISyntaxNode  min = FindMinPrioritiOperation(listNode, out position);
        if (listBinaryOperations.IndexOf(min.ToStringValue()) != -1)
        {
            BinaryOperation operation = min as BinaryOperation;
            operation.SetA(BuildSyntaxTree(listNode.GetRange(0, position)));
            operation.SetB(BuildSyntaxTree(listNode.GetRange(position + 1,listNode.Count - (position +1))));
        }
        if (listUnaryOperations.IndexOf(min.ToStringValue()) != -1)
        {
            UnaryOperation operation = min as UnaryOperation;
            operation.SetA(BuildSyntaxTree(listNode.GetRange(position + 1, listNode.Count - (position + 1))));
        }
        if (listFunctions.IndexOf(min.ToStringValue()) != -1)
        {
            Function function = min as Function;
            function.SetX(BuildSyntaxTree(listNode.GetRange(position + 1, listNode.Count - (position + 1))));
        }
        return min;
    }

Method `DeleteExcessiveBrackets` deletes excessive brackets. Sample: expression before executing the method - ((9-x)\*17-2); expression after execution method - (9-x)\*17-2.

![delete_excessive_brackets.png][]

Method `FindMinPrioritiOperation` seeking operation is the lowest priority. Sample: expression - (9-x)\*17-2; result - operation - and position 7.

![min_priority_operation.png][]

Drawing graphics

![minus.gif][]  Collapse  |  [Copy Code][]

private void DrawFunction(string function, Color functionColor)
    {
        int sizeX = panelGraphFunction.Size.Width;
        int sizeY = panelGraphFunction.Size.Height;
        double minX = -10, maxX = 10;
        double minY = -10, maxY = 10;
    
        minX = Convert.ToDouble(textBoxMinX.Text);
        maxX = Convert.ToDouble(textBoxMaxX.Text);
        minY = Convert.ToDouble(textBoxMinY.Text);
        maxY = Convert.ToDouble(textBoxMaxY.Text);
    
        SyntaxTree calculator = new SyntaxTree(function);
    
        Graphics g = panelGraphFunction.CreateGraphics();
    
        Point currentPoint = new Point();
        Point previousPoint = new Point();
        bool isCurentPoint = false;
        bool isPreviousPoint = false;
        for (double x = minX; x < maxX; x += (maxX - minX) / sizeX)
        {
            double y = calculator.Calculate(x, out isCurentPoint);
            if (Math.Abs(y) > maxY * 2) isCurentPoint = false;
            if (isCurentPoint)
            {
                currentPoint.X = (int)(x / ((maxX - minX) / sizeX) - minX / ((maxX - minX) / (double)sizeX));
                currentPoint.Y = (int)(sizeY - (y / ((maxY - minY) / sizeY) - minY / ((maxY - minY) / (double)sizeY)));
                if (isPreviousPoint)
                {
                    g.DrawLine(new Pen(functionColor, 2), previousPoint, currentPoint);
                }
            }
            previousPoint = currentPoint;
            isPreviousPoint = isCurentPoint;
        }
    }

[http_www.codeproject.com_Articles_713686_Graph-of-Function]: http://www.codeproject.com/Articles/713686/Graph-of-Function
[Download GraphOfFunction-noexe.zip - 245.2 KB]: http://www.codeproject.com/KB/cs/713686/GraphOfFunction-noexe.zip
[Download GraphOfFunction.zip - 404.5 KB]: http://www.codeproject.com/KB/cs/713686/GraphOfFunction.zip
[home_window.png]: /images/20220810/925b9c2fe06c4432926ec1be402a57d2.png
[function_window.png]: /images/20220810/ff4911a249d749d59dca5c955bb527fd.png
[architecture.png]: /images/20220810/80af9fb7bc3d4ad3a2c9ffd183d5a76b.png
[minus.gif]: /images/20220810/d9fa2731605245f7b946c7f859db98f1.png
[Copy Code]: http://www.codeproject.com/Articles/713686/Graph-of-Function#
[delete_excessive_brackets.png]: /images/20220810/212566b20b9941bbb40f79e9e91cff8a.png
[min_priority_operation.png]: /images/20220810/90f8a4d0858e4e59819ce4ea785b992b.png