private void btnCalculate_Click(object sender, RoutedEventArgs e)
        {
            Operations o = new Operations();

            if (optAdd.IsChecked == true)
            {
                double addResult = add(Convert.ToDouble(txtFirstNumber.Text), Convert.ToDouble(txtSecondNumber.Text));
                txtResult.Text = "" + addResult;
            }
            else if (optSub.IsChecked == true)
            {
                double subResult = sub(Convert.ToDouble(txtFirstNumber.Text), Convert.ToDouble(txtSecondNumber.Text));
                txtResult.Text = "" + subResult;
            }
            else if (optMult.IsChecked == true)
            {
                double multResult = mult(Convert.ToDouble(txtFirstNumber.Text), Convert.ToDouble(txtSecondNumber.Text));
                txtResult.Text = "" + multResult;
            }
            else if (optDiv.IsChecked == true)
            {
                double divResult = sub(Convert.ToDouble(txtFirstNumber.Text), Convert.ToDouble(txtSecondNumber.Text));
                txtResult.Text = "" + divResult;
            }
        }

        internal static void TestOperation(double number, Operations operation)
        {
            storeResults.Clear();
            for (int i = 0; i < OperationRepeatCount; i++)
            {
                watchTime.Reset();
                watchTime.Start();
                for (int j = 0; j < LoopsCount; j++)
                {
                    switch (operation)
                    {
                        case Operations.Sqrt:
                            result = Math.Sqrt(number);
                            break;
                        case Operations.Log:
                            result = Math.Log(number);
                            break;
                        case Operations.Sin:
                            result = Math.Sin(number);
                            break;
                        default:
                            throw new InvalidOperationException("You have entered an invalid operation");
                    }
                }

                watchTime.Stop();
                storeResults.Add(watchTime.Elapsed.Milliseconds);
            }

            double averageResult = storeResults.Average();
            Console.WriteLine("Math {0} with double finished in {1} miliseconds", operation, averageResult);
        }

		public ValueAssignEx(Text.Span span, Operations operation, VariableUse/*!*/ lvalue, Expression/*!*/ rvalue)
			: base(span)
		{
			this.lvalue = lvalue;
			this.rvalue = rvalue;
			this.operation = operation;
		}

        public static CalculationHandler GetOperation(Operations op)
        {
            switch (op)
            {
                case Operations.Addition:
                    return (x, y) => x + y + "";
                case Operations.Division:
                    return (x, y) =>
                    {
                        if (y.Equals(0))
                            return " Cannot divide by zero";

                        return x/y + "";
                    };
                case Operations.Multiplication:
                    return (x, y) => x*y + "";
                case Operations.Substraction:
                    return (x, y) => x - y + "";
                case Operations.Sqrt:
                    return (x, y) => Math.Sqrt(x) + "";
                case Operations.Mod:
                    return (x, y) => x%y + "";
                case Operations.Reciprocal:
                    return (x, y) =>
                    {
                        if (x.Equals(0))
                            return " Cannot divide by zero";
                        return 1/x + "";
                    };
            }
            return null;
        }

        public CalculatorViewModel()
        {
            _calculator = new CalculatorSimple();
            _operation = Operations.None;

            AddCommand = new ActionCommand(Add);
            SubtractCommand = new ActionCommand(Subtract);
            MultiplyCommand = new ActionCommand(Multiply);
            DivideCommand = new ActionCommand(Divide);
            EquateCommand = new ActionCommand(Equate);

            ZeroCommand = new ActionCommand(() => InputSymbol('0'));
            OneCommand = new ActionCommand(() => InputSymbol('1'));
            TwoCommand = new ActionCommand(() => InputSymbol('2'));
            ThreeCommand = new ActionCommand(() => InputSymbol('3'));
            FourCommand = new ActionCommand(() => InputSymbol('4'));
            FiveCommand = new ActionCommand(() => InputSymbol('5'));
            SixCommand = new ActionCommand(() => InputSymbol('6'));
            SevenCommand = new ActionCommand(() => InputSymbol('7'));
            EightCommand = new ActionCommand(() => InputSymbol('8'));
            NineCommand = new ActionCommand(() => InputSymbol('9'));
            MarkCommand = new ActionCommand(() => InputSymbol(','));

            RemoveLastDigitCommand = new ActionCommand(RemoveLastDigit);
            ClearCommand = new ActionCommand(Clear);
            PlusMinusCommand = new ActionCommand(ChangeSign);
        }

        public UnaryEx(Text.Span span, Operations operation, Expression/*!*/ expr)
			: base(span)
		{
			Debug.Assert(expr != null);
			this.operation = operation;
			this.expr = expr;
		}

		public ValueAssignEx(Position position, Operations operation, VariableUse/*!*/ lvalue, Expression/*!*/ rvalue)
			: base(position)
		{
			this.lvalue = lvalue;
			this.rvalue = rvalue;
			this.operation = operation;
		}

        private void ImportOneUnit(MCS.Library.SOA.DataObjects.Security.SCObjectSet objectSet, Operations.IFacade exec, ImportContextWrapper wrapper, SchemaObjectBase parent, int totalSteps, AdminUnit unit)
        {
            int currentStep = 0;
            var scopes = (from m in objectSet.Membership where m.ContainerID == unit.ID && m.MemberSchemaType == AUCommon.SchemaAUAdminScope && m.Status == Schemas.SchemaProperties.SchemaObjectStatus.Normal join o in objectSet.Objects on m.ID equals o.ID where o.SchemaType == AUCommon.SchemaAUAdminScope && o.Status == Schemas.SchemaProperties.SchemaObjectStatus.Normal select (AUAdminScope)o).ToArray();
            var roles = (from m in objectSet.Membership where m.ContainerID == unit.ID && m.MemberSchemaType == AUCommon.SchemaAdminUnitRole && m.Status == Schemas.SchemaProperties.SchemaObjectStatus.Normal join o in objectSet.Objects on m.ID equals o.ID where o.SchemaType == AUCommon.SchemaAdminUnitRole && o.Status == Schemas.SchemaProperties.SchemaObjectStatus.Normal select (AURole)o).ToArray();
            try
            {
                currentStep++;
                wrapper.SetStatusAndLog(currentStep, totalSteps, "正在导入管理单元" + unit.GetQualifiedName());
                exec.AddAdminUnitWithMembers(unit, (AdminUnit)parent, roles, scopes);
                ImportRoleMembers(objectSet, exec, wrapper, totalSteps, unit, currentStep, roles);

                ImportConditions(objectSet, exec, wrapper, totalSteps, unit, currentStep, scopes);

                if (this.ImportSubUnits)
                {
                    wrapper.IncreaseLevel();
                    var subs = (from r in objectSet.Relations where r.ParentID == unit.ID && r.ChildSchemaType == AUCommon.SchemaAdminUnit && r.Status == Schemas.SchemaProperties.SchemaObjectStatus.Normal join o in objectSet.Objects on r.ID equals o.ID where o.Status == Schemas.SchemaProperties.SchemaObjectStatus.Normal && o.SchemaType == AUCommon.SchemaAdminUnit select (AdminUnit)o).ToArray();
                    int count = subs.Length;
                    foreach (AdminUnit s in subs)
                    {
                        ImportOneUnit(objectSet, exec, wrapper, unit, count, s);
                    }

                    wrapper.DecreaseLevel();
                }
            }
            catch (Exception ex)
            {
                wrapper.IncreaseError();
                wrapper.SetStatusAndLog(currentStep, totalSteps, string.Format("导入单元 {0} 失败，原因是：{1}", unit.GetQualifiedName(), ex.ToString()));
            }
        }

		public UnaryEx(Position position, Operations operation, Expression/*!*/ expr)
			: base(position)
		{
			Debug.Assert(expr != null);
			this.operation = operation;
			this.expr = expr;
		}

        public static void ComparePerformance(float value, Operations funcion)
        {
            var result = value;
            Stopwatch stopwatch = new Stopwatch();

            for (var j = 0; j < TestsCount; j++)
            {
                var testNumber = value;
                stopwatch.Start();

                for (var i = 0; i < RepeatFunctionsCount; i++)
                {
                    switch (funcion)
                    {
                        case Operations.Add: testNumber += anotherValue; break;
                        case Operations.Division: testNumber %= anotherValue; break;
                        case Operations.Substraction: testNumber -= anotherValue; break;
                        case Operations.Multiply: testNumber *= anotherValue; break;
                        case Operations.Increment: testNumber++; break;
                    }
                }

                stopwatch.Stop();
            }
            Console.WriteLine(value.GetType().ToString() + " time in milliseconds: " + stopwatch.Elapsed.Milliseconds / TestsCount);
        }

		public BinaryEx(Position position, Operations operation, Expression/*!*/ leftExpr, Expression/*!*/ rightExpr)
			: base(position)
		{
			Debug.Assert(leftExpr != null && rightExpr != null);
			this.operation = operation;
			this.leftExpr = leftExpr;
			this.rightExpr = rightExpr;
		}

 public void Operation(Operations operation)
 {
     Random rand = new Random(84329);
     Vector4 v1 = new Vector4(Convert.ToSingle(rand.NextDouble()), Convert.ToSingle(rand.NextDouble()), Convert.ToSingle(rand.NextDouble()), Convert.ToSingle(rand.NextDouble()));
     Vector4 v2 = new Vector4(Convert.ToSingle(rand.NextDouble()), Convert.ToSingle(rand.NextDouble()), Convert.ToSingle(rand.NextDouble()), Convert.ToSingle(rand.NextDouble()));
     foreach (var iteration in Benchmark.Iterations)
         using (iteration.StartMeasurement())
             ExecuteTest(operation, 1000000, v1, v2);
 }

 public bool OperationValidity(Operations operation)
 {
     switch(operation)
     {
         case Operations.EditClient:
             return CanEditClient();
     }
     return false;
 }

        public static void Run(string[] args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            ProgramOptions options = new ProgramOptions();

            string settingPath = Path.Combine(Path.GetDirectoryName(Application.ExecutablePath), "Oxel.Settings.xml");
            VoxelizationInput input = VoxelizationInput.Load(settingPath);
            if (input == null)
                input = new VoxelizationInput();

            if (args.Contains("-c"))
            {
                // Make sure user can see console output
                AttachConsole(PARENT_PROCESS_ID);

                input.Clone(options);

                if (!CommandLineParser.Parse<ProgramOptions>(args, ref options))
                    return;

                options.Clone(input);
            }
            else
            {
                CommandLineParser.Parse<VoxelizationInput>(args, ref input);
            }

            if (options.UseCommandLine)
            {
                Logger.IsCommandLine = true;

                Operations operations = new Operations();
                operations.Initialize(input);
                operations.Open(options.InputMesh, input.WindingOrder);
                WaitHandle waitHandle = operations.GenerateOccluder((VoxelizationProgress vp) => {
                    string coverage =
                        String.Format("Volume Coverage     : {0,5:0.##}%", (100 * vp.VolumeCoverage)) + "    " +
                        String.Format("Silhouette Coverage : {0,5:0.##}%", (100 * vp.SilhouetteCoverage));

                    if (!String.IsNullOrEmpty(vp.Status))
                        Console.WriteLine(vp.Status + "\r\n");

                    Console.WriteLine(coverage);
                }, new Action(() => { }));
                waitHandle.WaitOne();
                operations.Save(options.OutputMesh);
            }
            else
            {
                using (MainWindow window = new MainWindow(input))
                {
                    window.ShowDialog();
                }
            }
        }

		public DeleteController(Operations.Delete delete)
		{
			if (delete == null)
			{
				throw new ArgumentNullException(nameof(delete));
			}

			Delete = delete;
		}

 public void ExecuteTest(Operations operation, int innerIterations, Vector3 v1, Vector3 v2)
 {
     Vector3 res;
     switch (operation)
     {
         case Operations.Add_Operator:
             for (int i = 0; i < innerIterations; i++)
             { res = v1 + v2; res = v1 + v2; res = v1 + v2; res = v1 + v2; res = v1 + v2; res = v1 + v2; res = v1 + v2; res = v1 + v2; res = v1 + v2; res = v1 + v2; }
             break;
         case Operations.Add_Function:
             for (int i = 0; i < innerIterations; i++)
             { Vector3.Add(v1, v2); Vector3.Add(v1, v2); Vector3.Add(v1, v2); Vector3.Add(v1, v2); Vector3.Add(v1, v2); Vector3.Add(v1, v2); Vector3.Add(v1, v2); Vector3.Add(v1, v2); Vector3.Add(v1, v2); Vector3.Add(v1, v2); }
             break;
         case Operations.Sub_Operator:
             for (int i = 0; i < innerIterations; i++)
             { res = v1 - v2; res = v1 - v2; res = v1 - v2; res = v1 - v2; res = v1 - v2; res = v1 - v2; res = v1 - v2; res = v1 - v2; res = v1 - v2; res = v1 - v2; }
             break;
         case Operations.Sub_Function:
             for (int i = 0; i < innerIterations; i++)
             { Vector3.Subtract(v1, v2); Vector3.Subtract(v1, v2); Vector3.Subtract(v1, v2); Vector3.Subtract(v1, v2); Vector3.Subtract(v1, v2); Vector3.Subtract(v1, v2); Vector3.Subtract(v1, v2); Vector3.Subtract(v1, v2); Vector3.Subtract(v1, v2); Vector3.Subtract(v1, v2); }
             break;
         case Operations.Mul_Operator:
             for (int i = 0; i < innerIterations; i++)
             { res = v1 * v2; res = v1 * v2; res = v1 * v2; res = v1 * v2; res = v1 * v2; res = v1 * v2; res = v1 * v2; res = v1 * v2; res = v1 * v2; res = v1 * v2; }
             break;
         case Operations.Mul_Function:
             for (int i = 0; i < innerIterations; i++)
             { Vector3.Multiply(v1, v2); Vector3.Multiply(v1, v2); Vector3.Multiply(v1, v2); Vector3.Multiply(v1, v2); Vector3.Multiply(v1, v2); Vector3.Multiply(v1, v2); Vector3.Multiply(v1, v2); Vector3.Multiply(v1, v2); Vector3.Multiply(v1, v2); Vector3.Multiply(v1, v2); }
             break;
         case Operations.Dot:
             for (int i = 0; i < innerIterations; i++)
             { Vector3.Dot(v1, v2); Vector3.Dot(v1, v2); Vector3.Dot(v1, v2); Vector3.Dot(v1, v2); Vector3.Dot(v1, v2); Vector3.Dot(v1, v2); Vector3.Dot(v1, v2); Vector3.Dot(v1, v2); Vector3.Dot(v1, v2); Vector3.Dot(v1, v2); }
             break;
         case Operations.SquareRoot:
             for (int i = 0; i < innerIterations; i++)
             { Vector3.SquareRoot(v1); Vector3.SquareRoot(v1); Vector3.SquareRoot(v1); Vector3.SquareRoot(v1); Vector3.SquareRoot(v1); Vector3.SquareRoot(v1); Vector3.SquareRoot(v1); Vector3.SquareRoot(v1); Vector3.SquareRoot(v1); Vector3.SquareRoot(v1); }
             break;
         case Operations.Length_Squared:
             for (int i = 0; i < innerIterations; i++)
             { v1.LengthSquared(); v1.LengthSquared(); v1.LengthSquared(); v1.LengthSquared(); v1.LengthSquared(); v1.LengthSquared(); v1.LengthSquared(); v1.LengthSquared(); v1.LengthSquared(); v1.LengthSquared(); }
             break;
         case Operations.Normalize:
             for (int i = 0; i < innerIterations; i++)
             { Vector3.Normalize(v1); Vector3.Normalize(v1); Vector3.Normalize(v1); Vector3.Normalize(v1); Vector3.Normalize(v1); Vector3.Normalize(v1); Vector3.Normalize(v1); Vector3.Normalize(v1); Vector3.Normalize(v1); Vector3.Normalize(v1); }
             break;
         case Operations.Distance_Squared:
             for (int i = 0; i < innerIterations; i++)
             { Vector3.DistanceSquared(v1, v2); Vector3.DistanceSquared(v1, v2); Vector3.DistanceSquared(v1, v2); Vector3.DistanceSquared(v1, v2); Vector3.DistanceSquared(v1, v2); Vector3.DistanceSquared(v1, v2); Vector3.DistanceSquared(v1, v2); Vector3.DistanceSquared(v1, v2); Vector3.DistanceSquared(v1, v2); Vector3.DistanceSquared(v1, v2); }
             break;
         case Operations.Cross:
             for (int i = 0; i < innerIterations; i++)
             { Vector3.Cross(v1, v2); Vector3.Cross(v1, v2); Vector3.Cross(v1, v2); Vector3.Cross(v1, v2); Vector3.Cross(v1, v2); Vector3.Cross(v1, v2); Vector3.Cross(v1, v2); Vector3.Cross(v1, v2); Vector3.Cross(v1, v2); Vector3.Cross(v1, v2); }
             break;
     }
 }

        /// <summary>
        /// Parses a given expression into a graph.
        /// </summary>
        /// <returns>The built graph.</returns>
        /// <param name="expression">The expression to create the graph from.</param>
        /// <param name="initGraph">The graph to append too. Used for recursion.</param>
        public Graph ParseExpression(string expression, Graph initGraph = null)
        {
            var lang = new Language ();
            var ops = new Operations ();
            expression = expression.Trim ();
            var opStack = new Stack<Word>();

            foreach (char letter in expression) {
                //find the language mapping
                var inLanguage = lang
                    .DefaultIfEmpty(null)
                    .FirstOrDefault (w => w.Letter == letter);

                //find the operation mapping
                var inOps = ops
                    .DefaultIfEmpty(null)
                    .FirstOrDefault(w => w.Letter == letter);

                //not in the language or operators
                if(inLanguage == null && inOps == null){
                    throw new InvalidLanguageException("Invalid input: " + letter);
                }

                //it is valid language input, so add it to the list.
                if(inLanguage != null){
                    opStack.Push(inLanguage);
                    continue;
                }
                else{
                    //not a letter, so must be an operation
                    //verify that it has the correct arg count for that type of operation.
                    if (opStack.Count != inOps.MinArgCount && initGraph == null) {
                        throw new InvalidLanguageException (
                            string.Format(
                                "Unbalanced arguement count for operation (expected {0}, but got {1}.",
                                inOps.MinArgCount, opStack.Count
                            ));
                    }
                    //operation, so stop, and process graph
                    initGraph = ProcessOperation(initGraph, inOps, opStack);
                }
            }

            //expression was given with no operation, so error out.
            if (opStack.Count > 0) {
                throw new InvalidLanguageException ("No operation was specified in the given expression.");
            }

            //once done with graph, renumber the states.
            initGraph.RenumberStates ();

            //return the completed graph.
            return initGraph;
        }

 private void ChangeValue(dynamic calculator, Operations operation)
 {
     dynamic addvalue = null;
     if (CurrentVal.Text != "Write your Value:")
     {
         if (state.CalcEnum == CalcEnum.IntCalc)
         {
             addvalue = new Real<int>(int.Parse(CurrentVal.Text));
         }
         if (state.CalcEnum == CalcEnum.FloatCalc)
         {
             addvalue = new Real<double>(double.Parse(CurrentVal.Text));
         }
         if (state.CalcEnum == CalcEnum.ComCalc)
         {
             addvalue = new Complecs(CurrentVal.Text);
         }
         switch (operation)
         {
             case Operations.Add:
                 calculator.Add(addvalue);
                 break;
             case Operations.Remove:
                 calculator.Remove(addvalue);
                 break;
             case Operations.Divide:
                 calculator.Divide(addvalue);
                 break;
             case Operations.Multiply:
                 calculator.Multiply(addvalue);
                 break;
             case Operations.Clear:
                 calculator.Clear(addvalue);
                 break;
             case Operations.Sqrt:
                 try
                 {
                     calculator.Sqrt(addvalue);
                 }
                 catch (Exception)
                 {
                     MessageBox.Show("Eror: Divide at 0");
                 }
                 break;
             case Operations.Modul:
                 calculator.Modul(addvalue);
                 break;
         }
     }
     else
     {
         MessageBox.Show("Write Value!!!!");
     }
 }

 public bool OperationValidity(Operations operation)
 {
     switch(operation)
     {
         case Operations.GenerateChallan:
             return CanGenerateChallan();
         case Operations.ViewChallan:
             return CanViewChallan();
     }
     return false;
 }

        public IOperation<Portrait> GetPortraitOperation()
        {
            var ops = new Operations<Portrait>();

            foreach (var portraitOperation in _portraitOperations)
            {
                ops.Register(portraitOperation);
            }

            return ops;
        }