1:

cos(e * 12) / (2 * (e * 6,28 + 1))                    

1:

(!Hugo xor pi > e ? cos(e * 12) / (2 * (e * 6,28 + 1)) : log(a; 3)) ^ 3 * 21 / 32                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:

using System;
using System.Collections.Generic;
using System.Text;
using Kha.GenPar; // enthält allgemeine Typen wie Variablen oder Basisklassen
using Kha.GenPar.Infix; // enthält den Infixparser und Zugehöriges
using System.Reflection; 

namespace ConsoleApplication1
{
  class Program
  {
    interface IGreatForum { } // Ein Forum ist einfach toll, das braucht keine Methoden ;)
    class CSharpForum : Object, IGreatForum { } // s.o ^^

    // Fangen wir gleich mal mit dem Ergebnis an, sonst wird es langweilig ;)
    static void Main(string[] args)
    {
      InfixParser parser = new InfixParser();
      // sucht in der angegebenen Klasse nach Parsertypen
      // (= Methoden mit Ableitungen von ParserAttribute)
      parser.RegisteredTypes.IncludeTypes(typeof(Program));
      // und noch eine Variable
      parser.RegisteredTypes.Variables.Add(new Variable(typeof(IGreatForum), "great"));

      parser.Parse("CSharpForum is great");
      Console.WriteLine(parser.Root.Evaluate());
      Console.ReadLine();
    }
    // Das Ergebnis versteht sich wohl von selbst :P

    // Und nun die Interna:

    // enthält alle in der Assembly definierten Typen
    static List<Type> classList = new List<Type>(Assembly.GetCallingAssembly().GetTypes());

    // Definieren wir mal schnell ein Literal...
    // God bless attributes
    //
    // Parst einen Typenbezeichner im String und gibt ein Type-Objekt zurück
    [SimpleLiteral()]
    public static Type ToType(string s, out int length, out bool succeeded)
    {
      foreach (Type t in classList)
        if (s.StartsWith(t.Name)) {
          length = t.Name.Length;
          succeeded = true;
          return t;
        }
      length = 42; // total egal, da succeeded eh false ist
      succeeded = false;
      return null;
    }

    // Und noch einen Operator
    // Meine Einstellung zu Attributen habe ich ja schon kundgegeben
    // 110 = Operatorvorrang (bei einem einzigen Operator ziemlich egal
    // \a = Argument
    [InfixOperator(110, @"\a is \a")]
    public static bool Is(Type t1, Type t2)
    {
      return t2.IsAssignableFrom(t1);
    }
  }
}                    

1:
2:
3:
4:
5:
6:
7:

static void Main(string[] args)
{
  InfixParser parser = new InfixParser(new Vector3Package());
  parser.Parse("(1; 0; 0) x (0; 2; 0)");
  Console.WriteLine(parser.Root.Evaluate());
  Console.ReadLine();
}                    

1:

this.justReal = Math.Abs(imaginary) < epsilon;  //HACK?