随笔-341  评论-2670  文章-0  trackbacks-0
    今天看到了校内上一个batman equation,觉得很顺不舒服。第一个是因为我觉得那个图是错的,第二个是因为这让我开始思考如何对任意的f(x, y)进行绘制。其实这是个很困难的问题。但是如果我假设f(x, y)是处处可微的,那么问题说不定会简单一点。因此今天晚上就忍不住开始写了。我的想法是,对于屏幕上的所有点,分别令x或者y等于该点的其中一个坐标元素,对f(x, y)的的另一个自变量做牛顿迭代法。这样所有的点最后就会收敛到一个点集,然后我把它画出来,大概就是函数图象了吧。

    不过因为开始思考的时候已经晚了,所以今天就只写了一点点代码,用C#,可以在Vczh Library++3.0的Candidate\Games\FunctionVisualizer找到(啊,我就是喜欢把代码都往Candidate里面塞)。现在完成的有,对于一个可以包含空格的表达式e,我把它语法分析称语法树,然后再对x和y求导,就得到了三颗语法树。然后我对他进行化简,就得到了六棵语法树。当然这个化简只是简单的,并没有对函数的组合进行处理。

    伟大的C#也是可以用指针的,啊哈哈哈哈,下面是语法分析的代码:
  1 using System;
  2 using System.Collections.Generic;
  3 using System.Linq;
  4 using System.Text;
  5 using FvCalculation.OperatorExpressions;
  6 using FvCalculation.PrimitiveExpressions;
  7 
  8 namespace FvCalculation
  9 {
 10     unsafe static class ExpressionParser
 11     {
 12         private static void SkipSpaces(char** input)
 13         {
 14             while (char.IsWhiteSpace(**input))
 15             {
 16                 (*input)++;
 17             }
 18         }
 19 
 20         private static bool Char(char** input, char c)
 21         {
 22             SkipSpaces(input);
 23             if (**input == c)
 24             {
 25                 (*input)++;
 26                 return true;
 27             }
 28             else
 29             {
 30                 return false;
 31             }
 32         }
 33 
 34         private static double Number(char** input)
 35         {
 36             SkipSpaces(input);
 37             bool dotted = false;
 38             string s = "";
 39             while (true)
 40             {
 41                 if ('0' <= **input && **input <= '9')
 42                 {
 43                     s += **input;
 44                     (*input)++;
 45                 }
 46                 else if ('.' == **input && !dotted)
 47                 {
 48                     dotted = true;
 49                     s += **input;
 50                     (*input)++;
 51                 }
 52                 else
 53                 {
 54                     break;
 55                 }
 56             }
 57             if (s == "")
 58             {
 59                 return double.NaN;
 60             }
 61             else
 62             {
 63                 return double.Parse(s);
 64             }
 65         }
 66 
 67         private static string Name(char** input)
 68         {
 69             SkipSpaces(input);
 70             string s = "";
 71             while (true)
 72             {
 73                 if (('a' <= **input && **input <= 'z'|| ('A' <= **input && **input <= 'Z'|| ('_' == **input) || (s != "" && '0' <= **input && **input <= '9'))
 74                 {
 75                     s += **input;
 76                     (*input)++;
 77                 }
 78                 else
 79                 {
 80                     break;
 81                 }
 82             }
 83             return s == "" ? null : s;
 84         }
 85 
 86         private static Expression Exp0(char** input)
 87         {
 88             if (Char(input, '('))
 89             {
 90                 Expression e = Exp3(input);
 91                 if (!Char(input, ')'))
 92                 {
 93                     throw new ArgumentException("Error encountered, at " + new string(*input));
 94                 }
 95                 return e;
 96             }
 97             else if (Char(input, '-'))
 98             {
 99                 return new NegExpression
100                 {
101                     Op = Exp0(input),
102                 };
103             }
104             else
105             {
106                 double number = Number(input);
107                 if (!double.IsNaN(number))
108                 {
109                     return new NumberExpression
110                     {
111                         Number = number,
112                     };
113                 }
114 
115                 string name = Name(input);
116                 if (name == null)
117                 {
118                     throw new ArgumentException("Error encountered, at " + new string(*input));
119                 }
120 
121                 if (!Char(input, '('))
122                 {
123                     return new VariableExpression
124                     {
125                         Name = name,
126                     };
127                 }
128 
129                 FunctionExpression f = FunctionExpression.FromName(name);
130                 f.Op = Exp3(input);
131                 if (!Char(input, ')'))
132                 {
133                     throw new ArgumentException("Error encountered, at " + new string(*input));
134                 }
135                 return f;
136             }
137         }
138 
139         private static Expression Exp1(char** input)
140         {
141             Expression e = Exp0(input);
142             while (true)
143             {
144                 if (Char(input, '^'))
145                 {
146                     e = new PowerExpression
147                     {
148                         Left = e,
149                         Right = Exp0(input),
150                     };
151                 }
152                 else
153                 {
154                     break;
155                 }
156             }
157             return e;
158         }
159 
160         private static Expression Exp2(char** input)
161         {
162             Expression e = Exp1(input);
163             while (true)
164             {
165                 if (Char(input, '*'))
166                 {
167                     e = new MulExpression
168                     {
169                         Left = e,
170                         Right = Exp1(input),
171                     };
172                 }
173                 else if (Char(input, '/'))
174                 {
175                     e = new DivExpression
176                     {
177                         Left = e,
178                         Right = Exp1(input),
179                     };
180                 }
181                 else
182                 {
183                     break;
184                 }
185             }
186             return e;
187         }
188 
189         private static Expression Exp3(char** input)
190         {
191             Expression e = Exp2(input);
192             while (true)
193             {
194                 if (Char(input, '+'))
195                 {
196                     e = new AddExpression
197                     {
198                         Left = e,
199                         Right = Exp2(input),
200                     };
201                 }
202                 else if (Char(input, '-'))
203                 {
204                     e = new SubExpression
205                     {
206                         Left = e,
207                         Right = Exp2(input),
208                     };
209                 }
210                 else
211                 {
212                     break;
213                 }
214             }
215             return e;
216         }
217 
218         private static Expression UnsafeParse(char* input)
219         {
220             Expression result = Exp3(&input);
221             if ((int)*input == 0)
222             {
223                 return result;
224             }
225             else
226             {
227                 throw new ArgumentException("Expression contains unparsed tail, at " + new string(input));
228             }
229         }
230 
231         public static Expression Parse(string s)
232         {
233             fixed (char* input = s.Trim())
234             {
235                 return UnsafeParse(input);
236             }
237         }
238     }
239 }
240 



    下面是运行结果:
  1 input:          1
  2 parse:          1
  3 reparse:        1
  4 simplified:     1
  5 contains x:     False
  6 contains y:     False
  7 dx:             0
  8 dy:             0
  9 simplified dx:  0
 10 simplified dy:  0
 11 
 12 input:          1.2
 13 parse:          1.2
 14 reparse:        1.2
 15 simplified:     1.2
 16 contains x:     False
 17 contains y:     False
 18 dx:             0
 19 dy:             0
 20 simplified dx:  0
 21 simplified dy:  0
 22 
 23 input:          -3
 24 parse:          -3
 25 reparse:        -3
 26 simplified:     -3
 27 contains x:     False
 28 contains y:     False
 29 dx:             -0
 30 dy:             -0
 31 simplified dx:  0
 32 simplified dy:  0
 33 
 34 input:          12+34
 35 parse:          (12 + 34)
 36 reparse:        (12 + 34)
 37 simplified:     46
 38 contains x:     False
 39 contains y:     False
 40 dx:             (0 + 0)
 41 dy:             (0 + 0)
 42 simplified dx:  0
 43 simplified dy:  0
 44 
 45 input:          56*78
 46 parse:          (56 * 78)
 47 reparse:        (56 * 78)
 48 simplified:     4368
 49 contains x:     False
 50 contains y:     False
 51 dx:             ((0 * 78+ (56 * 0))
 52 dy:             ((0 * 78+ (56 * 0))
 53 simplified dx:  0
 54 simplified dy:  0
 55 
 56 input:          x^y
 57 parse:          (x ^ y)
 58 reparse:        (x ^ y)
 59 simplified:     (x ^ y)
 60 contains x:     True
 61 contains y:     True
 62 dx:             (y * (x ^ (y - 1)))
 63 dy:             ((x ^ y) * ln(x))
 64 simplified dx:  (y * (x ^ (y - 1)))
 65 simplified dy:  ((x ^ y) * ln(x))
 66 
 67 input:          x+2*y+4
 68 parse:          ((x + (2 * y)) + 4)
 69 reparse:        ((x + (2 * y)) + 4)
 70 simplified:     ((x + (2 * y)) + 4)
 71 contains x:     True
 72 contains y:     True
 73 dx:             ((1 + ((0 * y) + (2 * 0))) + 0)
 74 dy:             ((0 + ((0 * y) + (2 * 1))) + 0)
 75 simplified dx:  1
 76 simplified dy:  2
 77 
 78 input:          (x+y)*(3+4)
 79 parse:          ((x + y) * (3 + 4))
 80 reparse:        ((x + y) * (3 + 4))
 81 simplified:     ((x + y) * 7)
 82 contains x:     True
 83 contains y:     True
 84 dx:             (((1 + 0* (3 + 4)) + ((x + y) * (0 + 0)))
 85 dy:             (((0 + 1* (3 + 4)) + ((x + y) * (0 + 0)))
 86 simplified dx:  7
 87 simplified dy:  7
 88 
 89 input:          exp(x+y)
 90 parse:          exp((x + y))
 91 reparse:        exp((x + y))
 92 simplified:     exp((x + y))
 93 contains x:     True
 94 contains y:     True
 95 dx:             (exp((x + y)) * (1 + 0))
 96 dy:             (exp((x + y)) * (0 + 1))
 97 simplified dx:  exp((x + y))
 98 simplified dy:  exp((x + y))
 99 
100 input:          x+ln(y)
101 parse:          (x + ln(y))
102 reparse:        (x + ln(y))
103 simplified:     (x + ln(y))
104 contains x:     True
105 contains y:     True
106 dx:             (1 + (0 / y))
107 dy:             (0 + (1 / y))
108 simplified dx:  1
109 simplified dy:  (1 / y)
110 
111 input:          x/y
112 parse:          (x / y)
113 reparse:        (x / y)
114 simplified:     (x / y)
115 contains x:     True
116 contains y:     True
117 dx:             (((1 * y) - (x * 0)) / (y ^ 2))
118 dy:             (((0 * y) - (x * 1)) / (y ^ 2))
119 simplified dx:  (y / (y ^ 2))
120 simplified dy:  (-/ (y ^ 2))
121 
122 input:          exp(x)/ln(x)
123 parse:          (exp(x) / ln(x))
124 reparse:        (exp(x) / ln(x))
125 simplified:     (exp(x) / ln(x))
126 contains x:     True
127 contains y:     False
128 dx:             ((((exp(x) * 1* ln(x)) - (exp(x) * (1 / x))) / (ln(x) ^ 2))
129 dy:             ((((exp(x) * 0* ln(x)) - (exp(x) * (0 / x))) / (ln(x) ^ 2))
130 simplified dx:  (((exp(x) * ln(x)) - (exp(x) * (1 / x))) / (ln(x) ^ 2))
131 simplified dy:  0
132 
133 请按任意键继续. . .

    最后一个simplified dy化简得真彻底啊……
posted on 2011-08-10 10:40 陈梓瀚(vczh) 阅读(4586) 评论(9)  编辑 收藏 引用 所属分类: .NET

评论:
# re: 函数绘图(一)[未登录] 2011-08-10 17:02 | joe
在这里要先转换到楼主语言才能阅读,不然会直接怀疑自己所学的语言  回复  更多评论
  
# re: 函数绘图(一)[未登录] 2011-08-10 17:18 | 空明流转
膜拜楼主!  回复  更多评论
  
# re: 函数绘图(一) 2011-08-10 18:33 | Pear
# re: 函数绘图(一)[未登录] 2011-08-10 23:47 | diryboy
这些公式拆开一个一个并起来才对,写到一个公式里的话,由于定义域的问题,即使能作出来也只能是一部分。  回复  更多评论
  
# re: 函数绘图(一) 2011-08-11 01:23 | 陈梓瀚(vczh)
@diryboy
求并==乘法  回复  更多评论
  
# re: 函数绘图(一) 2011-08-12 02:20 | DiryBoy
@陈梓瀚(vczh)
例如 (1/x-1)*(1/(x-1)+1)=0 这条等式,如果你认为x可以等于0或1那我也没话说。  回复  更多评论
  
# re: 函数绘图(一) 2011-08-12 09:34 | 陈梓瀚(vczh)
@DiryBoy
这个嘛,显然不能在没有定义的点上做乘法,不需明说。  回复  更多评论
  
# re: 函数绘图(一)[未登录] 2011-08-13 21:05 | diryboy
@陈梓瀚(vczh)
所以 求并!=乘法  回复  更多评论
  
# re: 函数绘图(一) 2011-08-26 02:30 | Junfeng
string而已,没必要用指针  回复  更多评论
  

只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理