source: trunk/CrypPlugins/RPNExpression/RPNExprFunctions.cs @ 1507

Last change on this file since 1507 was 841, checked in by Sören Rinne, 12 years ago
  • some changes in BM, BFP, LFSR, NLFSR
  • BFP now accepts x*.* instead of i_*.*
  • added 2 function parsers
File size: 14.5 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Text;
4
5namespace Cryptool.RPNExpression
6{
7    public static class RPNFunctionUtils
8    {
9        public const string cFuncGroupLogical = "Logical";
10        public const string cFuncGroupDateTime = "Date & Time";
11        public const string cFuncGroupConvert = "Convert";
12        public const string cFuncGroupString = "String";
13        public const string cFuncGroupMath = "Math";
14
15        public static void RegisterFunctions(ExprEnvironment pEnvironment)
16        {
17            pEnvironment.RegisterFunction(typeof(IfFunction));
18            pEnvironment.RegisterFunction(typeof(NowFunction));
19            pEnvironment.RegisterFunction(typeof(DateFunction));
20            pEnvironment.RegisterFunction(typeof(TimeFunction));
21            pEnvironment.RegisterFunction(typeof(DayFunction));
22            pEnvironment.RegisterFunction(typeof(MonthFunction));
23            pEnvironment.RegisterFunction(typeof(YearFunction));
24            pEnvironment.RegisterFunction(typeof(StrToNumFunction));
25            pEnvironment.RegisterFunction(typeof(StrToDateFunction));
26            pEnvironment.RegisterFunction(typeof(StrToTimeFunction));
27            pEnvironment.RegisterFunction(typeof(NumToStrFunction));
28            pEnvironment.RegisterFunction(typeof(DateToStrFunction));
29            pEnvironment.RegisterFunction(typeof(TimeToStrFunction));
30            pEnvironment.RegisterFunction(typeof(UpperFunction));
31            pEnvironment.RegisterFunction(typeof(LowerFunction));
32            pEnvironment.RegisterFunction(typeof(CopyFunction));
33            pEnvironment.RegisterFunction(typeof(TrimFunction));
34            pEnvironment.RegisterFunction(typeof(LenFunction));
35            pEnvironment.RegisterFunction(typeof(ReplaceFunction));
36            pEnvironment.RegisterFunction(typeof(AbsFunction));
37            pEnvironment.RegisterFunction(typeof(RoundFunction));
38            pEnvironment.RegisterFunction(typeof(RandomFunction));
39            pEnvironment.RegisterFunction(typeof(SumFunction));
40            pEnvironment.RegisterFunction(typeof(MaxFunction));
41            pEnvironment.RegisterFunction(typeof(MinFunction));
42            pEnvironment.RegisterFunction(typeof(AverageFunction));
43            pEnvironment.RegisterFunction(typeof(CountFunction));
44
45            pEnvironment.RegisterFunction(typeof(ACosFunction));
46            pEnvironment.RegisterFunction(typeof(ASinFunction));
47            pEnvironment.RegisterFunction(typeof(ATanFunction));
48            pEnvironment.RegisterFunction(typeof(CosFunction));
49            pEnvironment.RegisterFunction(typeof(CoshFunction));
50            pEnvironment.RegisterFunction(typeof(ExpFunction));
51            pEnvironment.RegisterFunction(typeof(LogFunction));
52            pEnvironment.RegisterFunction(typeof(Log10Function));
53            pEnvironment.RegisterFunction(typeof(SinFunction));
54            pEnvironment.RegisterFunction(typeof(SinhFunction));
55            pEnvironment.RegisterFunction(typeof(SqrtFunction));
56            pEnvironment.RegisterFunction(typeof(TanFunction));
57            pEnvironment.RegisterFunction(typeof(TanhFunction));
58            pEnvironment.RegisterFunction(typeof(PIFunction));
59        }
60    }
61
62    [Function("IF", ParamNames="logicaltest; value if true; value if false", ParamTypes="BAA", Group=RPNFunctionUtils.cFuncGroupLogical)]
63    public class IfFunction : RPNFunction
64    {
65        public override object Calc()
66        {
67            if ((bool)Params[0])
68                return Params[1];
69            else
70                return Params[2]; 
71        }
72    }
73
74    [Function("NOW", Group = RPNFunctionUtils.cFuncGroupDateTime)]
75    public class NowFunction : RPNFunction
76    {
77        public override object Calc()
78        {
79            return DateTime.Now;
80        }
81    }
82
83    [Function("DATE", Group = RPNFunctionUtils.cFuncGroupDateTime)]
84    public class DateFunction : RPNFunction
85    {
86        public override object Calc()
87        {
88            return DateTime.Today;
89        }
90    }
91
92    [Function("TIME", Group = RPNFunctionUtils.cFuncGroupDateTime)]
93    public class TimeFunction : RPNFunction
94    {
95        public override object Calc()
96        {
97            return DateTime.Now.TimeOfDay;
98        }
99    }
100
101    [Function("DAY", ParamTypes = "D", Group = RPNFunctionUtils.cFuncGroupDateTime)]
102    public class DayFunction : RPNFunction
103    {
104        public override object Calc()
105        {
106            return ((DateTime)Params[0]).Day;
107        }
108    }
109
110    [Function("MONTH", ParamTypes = "D", Group = RPNFunctionUtils.cFuncGroupDateTime)]
111    public class MonthFunction : RPNFunction
112    {
113        public override object Calc()
114        {
115            return ((DateTime)Params[0]).Month;
116        }
117    }
118
119    [Function("YEAR", ParamTypes = "D", Group = RPNFunctionUtils.cFuncGroupDateTime)]
120    public class YearFunction : RPNFunction
121    {
122        public override object Calc()
123        {
124            return ((DateTime)Params[0]).Year;
125        }
126    }
127
128    [Function("STRTONUM", ParamTypes = "S", Group = RPNFunctionUtils.cFuncGroupConvert)]
129    public class StrToNumFunction : RPNFunction
130    {
131        public override object Calc()
132        {
133            return Convert.ToString(Params[0]);
134        }
135    }
136
137    [Function("STRTODATE", ParamTypes = "S", Group = RPNFunctionUtils.cFuncGroupConvert)]
138    public class StrToDateFunction : RPNFunction
139    {
140        public override object Calc()
141        {
142            return Convert.ToDateTime(Params[0]);
143        }
144    }
145
146    [Function("STRTOTIME", ParamTypes = "S", Group = RPNFunctionUtils.cFuncGroupConvert)]
147    public class StrToTimeFunction : RPNFunction
148    {
149        public override object Calc()
150        {
151            return Convert.ToDateTime(Params[0]);
152        }
153    }
154
155    [Function("NUMTOSTR", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupConvert)]
156    public class NumToStrFunction : RPNFunction
157    {
158        public override object Calc()
159        {
160            return Convert.ToString(Params[0]);
161        }
162    }
163
164    [Function("DATETOSTR", ParamTypes = "D", Group = RPNFunctionUtils.cFuncGroupConvert)]
165    public class DateToStrFunction : RPNFunction
166    {
167        public override object Calc()
168        {
169            return Convert.ToString(Params[0]);
170        }
171    }
172
173    [Function("TIMETOSTR", ParamTypes = "D", Group = RPNFunctionUtils.cFuncGroupConvert)]
174    public class TimeToStrFunction : RPNFunction
175    {
176        public override object Calc()
177        {
178            return Convert.ToString(Params[0]);
179        }
180    }
181
182    [Function("UPPER", ParamTypes = "S", Group = RPNFunctionUtils.cFuncGroupString)]
183    public class UpperFunction : RPNFunction
184    {
185        public override object Calc()
186        {
187            return Convert.ToString(Params[0]).ToUpper();
188        }
189    }
190
191    [Function("LOWER", ParamTypes = "S", Group = RPNFunctionUtils.cFuncGroupString)]
192    public class LowerFunction : RPNFunction
193    {
194        public override object Calc()
195        {
196            return Convert.ToString(Params[0]).ToLower();
197        }
198    }
199
200    [Function("COPY", ParamTypes = "SNN", Group = RPNFunctionUtils.cFuncGroupString)]
201    public class CopyFunction : RPNFunction
202    {
203        public override object Calc()
204        {
205            return Convert.ToString(Params[0]).Substring(Convert.ToInt32(Params[1]), Convert.ToInt32(Params[2]));
206        }
207    }
208
209    [Function("TRIM", ParamTypes = "S", Group = RPNFunctionUtils.cFuncGroupString)]
210    public class TrimFunction : RPNFunction
211    {
212        public override object Calc()
213        {
214            return Convert.ToString(Params[0]).Trim();
215        }
216    }
217
218    [Function("LEN", ParamTypes = "S", Group = RPNFunctionUtils.cFuncGroupString)]
219    public class LenFunction : RPNFunction
220    {
221        public override object Calc()
222        {
223            return Convert.ToString(Params[0]).Length;
224        }
225    }
226
227    [Function("REPLACE", ParamTypes = "SSS", Group = RPNFunctionUtils.cFuncGroupString)]
228    public class ReplaceFunction : RPNFunction
229    {
230        public override object Calc()
231        {
232            return Convert.ToString(Params[0]).Replace(Convert.ToString(Params[1]), Convert.ToString(Params[2]));
233        }
234    }
235
236    [Function("ABS", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
237    public class AbsFunction : RPNFunction
238    {
239        public override object Calc()
240        {
241            return Math.Abs(Convert.ToDouble(Params[0]));
242        }
243    }
244
245    [Function("ROUND", ParamTypes = "NN", Group = RPNFunctionUtils.cFuncGroupMath)]
246    public class RoundFunction : RPNFunction
247    {
248        public override object Calc()
249        {
250            return Math.Round(Convert.ToDouble(Params[0]), Convert.ToInt32(Params[1]));
251        }
252    }
253
254    [Function("RANDOM", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
255    public class RandomFunction : RPNFunction
256    {
257        public override object Calc()
258        {
259            Random random = new Random();
260            return random.Next(Convert.ToInt32(Params[0]));
261        }
262    }
263
264    [Function("SUM", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
265    public class SumFunction : RPNAggregateFunction
266    {
267        public override void Aggregate()
268        {
269            base.Aggregate();
270            Value += Convert.ToDouble(Owner.RPNList[Owner.Position].GetValue());
271        }
272    }
273
274    [Function("MAX", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
275    public class MaxFunction : RPNAggregateFunction
276    {
277        public override void Aggregate()
278        {
279            bool b = Count == 0;
280            base.Aggregate();
281            double number = Convert.ToDouble(Owner.RPNList[Owner.Position].GetValue());
282            if (b || number > Value)
283                Value = number;
284        }
285    }
286
287    [Function("MIN", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
288    public class MinFunction : RPNAggregateFunction
289    {
290        public override void Aggregate()
291        {
292            bool b = Count == 0;
293            base.Aggregate();
294            double number = Convert.ToDouble(Owner.RPNList[Owner.Position].GetValue());
295            if (b || number < Value)
296                Value = number;
297        }
298    }
299
300    [Function("AVERAGE", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
301    public class AverageFunction : RPNAggregateFunction
302    {
303        public override object Calc()
304        {
305            return Value / Count;
306        }
307
308        public override void Aggregate()
309        {
310            base.Aggregate();
311            Value += Convert.ToDouble(Owner.RPNList[Owner.Position].GetValue());
312        }
313    }
314
315    [Function("COUNT", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
316    public class CountFunction : RPNAggregateFunction
317    {
318        public override void Aggregate()
319        {
320            base.Aggregate();
321            Value += 1;
322        }
323    }
324
325    [Function("ACOS", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
326    public class ACosFunction : RPNFunction
327    {
328        public override object Calc()
329        {
330            return Math.Acos(Convert.ToDouble(Params[0]));
331        }
332    }
333
334    [Function("ASIN", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
335    public class ASinFunction : RPNFunction
336    {
337        public override object Calc()
338        {
339            return Math.Asin(Convert.ToDouble(Params[0]));
340        }
341    }
342
343    [Function("ATAN", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
344    public class ATanFunction : RPNFunction
345    {
346        public override object Calc()
347        {
348            return Math.Atan(Convert.ToDouble(Params[0]));
349        }
350    }
351
352    [Function("COS", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
353    public class CosFunction : RPNFunction
354    {
355        public override object Calc()
356        {
357            return Math.Cos(Convert.ToDouble(Params[0]));
358        }
359    }
360
361    [Function("COSH", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
362    public class CoshFunction : RPNFunction
363    {
364        public override object Calc()
365        {
366            return Math.Cosh(Convert.ToDouble(Params[0]));
367        }
368    }
369
370    [Function("EXP", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
371    public class ExpFunction : RPNFunction
372    {
373        public override object Calc()
374        {
375            return Math.Exp(Convert.ToDouble(Params[0]));
376        }
377    }
378
379    [Function("LOG", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
380    public class LogFunction : RPNFunction
381    {
382        public override object Calc()
383        {
384            return Math.Log(Convert.ToDouble(Params[0]));
385        }
386    }
387
388    [Function("LOG10", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
389    public class Log10Function : RPNFunction
390    {
391        public override object Calc()
392        {
393            return Math.Log10(Convert.ToDouble(Params[0]));
394        }
395    }
396
397    [Function("SIN", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
398    public class SinFunction : RPNFunction
399    {
400        public override object Calc()
401        {
402            return Math.Sin(Convert.ToDouble(Params[0]));
403        }
404    }
405
406    [Function("SINH", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
407    public class SinhFunction : RPNFunction
408    {
409        public override object Calc()
410        {
411            return Math.Sinh(Convert.ToDouble(Params[0]));
412        }
413    }
414
415    [Function("SQRT", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
416    public class SqrtFunction : RPNFunction
417    {
418        public override object Calc()
419        {
420            return Math.Sqrt(Convert.ToDouble(Params[0]));
421        }
422    }
423
424    [Function("TAN", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
425    public class TanFunction : RPNFunction
426    {
427        public override object Calc()
428        {
429            return Math.Tan(Convert.ToDouble(Params[0]));
430        }
431    }
432
433    [Function("TANH", ParamTypes = "N", Group = RPNFunctionUtils.cFuncGroupMath)]
434    public class TanhFunction : RPNFunction
435    {
436        public override object Calc()
437        {
438            return Math.Tanh(Convert.ToDouble(Params[0]));
439        }
440    }
441
442    [Function("PI", Group = RPNFunctionUtils.cFuncGroupMath)]
443    public class PIFunction : RPNFunction
444    {
445        public override object Calc()
446        {
447            return Math.PI;
448        }
449    }
450}
Note: See TracBrowser for help on using the repository browser.