//所有数字按钮（含小数点）
        private void NumberButton_Click(object sender, RoutedEventArgs e)
        {
            Button button = sender as Button;
            if (IsEqualPress)
            {
                FirstNumber.NumString.Clear();
                FirstNumber.NumString.Append("0");
                FirstNumber.Num = 0;
                IsEqualPress = false;
            }

            if (IsFirstNum)
            {
                FirstNumber = JudgeInput(FirstNumber, button);
                ShowResultTextBlock.Text = FirstNumber.NumString.ToString();
                if (ShowResultTextBlock.Text.Length > 8)
                    ShowResultTextBlock.FontSize = 90 * 8 / ShowResultTextBlock.Text.Length;
                else
                    ShowResultTextBlock.FontSize = 90;
            }
            else
            {
                SecondNumber = JudgeInput(SecondNumber, button);
                ShowResultTextBlock.Text = SecondNumber.NumString.ToString();
                if (ShowResultTextBlock.Text.Length > 8)
                    ShowResultTextBlock.FontSize = 90 * 8 / ShowResultTextBlock.Text.Length;
                else
                    ShowResultTextBlock.FontSize = 90;
            }

        }

        /// <summary>
        /// Declares a variable if there is a declaration and deletes unnessesary stuff
        /// </summary>
        /// <param name="listE"> stream of tokens </param>
        /// <returns> true if we need to launch the function again </returns>
        public static bool DeclareVariable(List<Element> listE)
        {
            if (listE.Count > 2) // it can be a declaration only if the list has more than 2 elements
            {
                if (listE[0].Type == C.Number && listE[1].Type == C.Control) // if it is a number
                {
                    string name = listE[0].GetNumber().Name;
                    if (name != "" && listE[1].ToString() == "=") // if it is a variable
                    {
                        listE.RemoveRange(0, 2);
                        Number num = new Number(Parse(listE).Value.ToString());
                        num.Name = name;
                        Variable.Add(num);

                        return false;
                    }
                }
            }

            int index = listE.FindIndex(delegate(Element e)
                                        { if (e.ToString() == "=") return true; return false; });
            if (index != -1) { listE.RemoveRange(0, index + 1); return true; }

            return false;
        }

        /// <summary>
        /// Creates a new instance of the AbsoluteNumber class
        /// </summary>
        /// <param name="nbr">The number that should be inside the absolute number</param>
        /// <exception cref="ArgumentNullException">Thrown if the number is null</exception>
        public AbsoluteNumber(Number nbr)
        {
            if(nbr == null)
                throw new ArgumentNullException(nameof(nbr),"The number can't be null");

            InnerValue = nbr;
        }

		private static bool HexNumberToInt64(ref Number.NumberBuffer number, ref long value)
		{
			ulong num = 0uL;
			bool result = Number.HexNumberToUInt64(ref number, ref num);
			value = (long)num;
			return result;
		}

		public override Number Subtract (Number x, Number y)
		{
			if (x.data.Length < 6 || y.data.Length < 6)
				return ToElement (base.Subtract (x, y));

			int cmp = x.CompareTo (y);
			if (cmp == 0)
				return PADDED_ZERO;
			uint[] pz = new uint[6], px = x.data, py = y.data;
			if (cmp > 0) {
				uint tmp, carry;
				tmp = py[0]; carry = ((pz[0] = px[0] - tmp) > ~tmp ? 1U : 0U);
				tmp = py[1] + carry; carry = (tmp < carry | (pz[1] = px[1] - tmp) > ~tmp ? 1U : 0U);
				tmp = py[2] + carry; carry = (tmp < carry | (pz[2] = px[2] - tmp) > ~tmp ? 1U : 0U);
				tmp = py[3] + carry; carry = (tmp < carry | (pz[3] = px[3] - tmp) > ~tmp ? 1U : 0U);
				tmp = py[4] + carry; carry = (tmp < carry | (pz[4] = px[4] - tmp) > ~tmp ? 1U : 0U);
				pz[5] = px[5] - py[5] - carry;
			} else {
				long tmp;
				int carry = 0;
				pz[0] = (uint)(tmp = ((long)px[0]) + ((long)P1) - ((long)py[0]) - carry); carry = (tmp < 0 ? 1 : tmp > 0xFFFFFFFF ? -1 : 0);
				pz[1] = (uint)(tmp = ((long)px[1]) + ((long)P2) - ((long)py[1]) - carry); carry = (tmp < 0 ? 1 : tmp > 0xFFFFFFFF ? -1 : 0);
				pz[2] = (uint)(tmp = ((long)px[2]) + ((long)P3) - ((long)py[2]) - carry); carry = (tmp < 0 ? 1 : tmp > 0xFFFFFFFF ? -1 : 0);
				pz[3] = (uint)(tmp = ((long)px[3]) + ((long)P4) - ((long)py[3]) - carry); carry = (tmp < 0 ? 1 : tmp > 0xFFFFFFFF ? -1 : 0);
				pz[4] = (uint)(tmp = ((long)px[4]) + ((long)P5) - ((long)py[4]) - carry); carry = (tmp < 0 ? 1 : tmp > 0xFFFFFFFF ? -1 : 0);
				pz[5] = (uint)(tmp = ((long)px[5]) + ((long)P6) - ((long)py[5]) - carry);
			}
			return new Number (pz);
		}

 public HslColor(Number hue, Number saturation, Number lightness, Number alpha)
 {
     Hue = (hue.ToNumber()/360d)%1d;
     Saturation = saturation.Normalize(100d)/100d;
     Lightness = lightness.Normalize(100d)/100d;
     Alpha = alpha.Normalize();
 }

 public Ending(Number number, Person person, Tense tense, Voice voice)
 {
     _number = number;
       _person = person;
       _tense = tense;
       _voice = voice;
 }

        static void Main(string[] args)
        {
            //constant
            var one = new Number<Bit>();
            one.Construct();

            //a few additions
            var two = one.Add(one);
            var three = one.Add(two);
            var six = three.Add(three);
            var ten = one.Add(three.Add(six));

            //proof that any regular object can be used, not just one which represents a bit
            var anotherOne = new Number<Number<Bit>>();
            anotherOne.Construct();
            var four = anotherOne.Add(anotherOne.Add(anotherOne.Add(anotherOne)));

            //display results
            Console.WriteLine("one: {0}: '{1}'", one.Evaluate(), one);
            Console.WriteLine("two: {0}: '{1}'", two.Evaluate(), two);
            Console.WriteLine("three: {0}: '{1}'", three.Evaluate(), three);
            Console.WriteLine("four: {0}: '{1}'", four.Evaluate(), four);
            Console.WriteLine("six: {0}: '{1}'", six.Evaluate(), six);
            Console.WriteLine("ten: {0}: '{1}'", ten.Evaluate(), ten);

            Console.ReadKey();
        }

		internal ECKeyPair (Number d, ECPoint Q, ECDomainParameters domain, ECDomainNames domainName)
		{
			_d = d;
			_Q = Q;
			_domain = domain;
			_domainName = domainName;
		}

		public Barrett (Number mod) : base (mod)
		{
			int len = mod.length << 1;
			constant = new Number (len + 1);
			constant.data[len] = 1;
			constant = constant / mod;
		}

		public override Number Add (Number x, Number y)
		{
			if (x.data.Length < 6 || y.data.Length < 6) return ToElement (base.Add (x, y));

			ulong sum;
			uint[] pz = new uint[7], px = x.data, py = y.data;
			uint tmp, carry;

			pz[0] = (uint)(sum = ((ulong)px[0]) + ((ulong)py[0])); sum >>= 32;
			pz[1] = (uint)(sum += ((ulong)px[1]) + ((ulong)py[1])); sum >>= 32;
			pz[2] = (uint)(sum += ((ulong)px[2]) + ((ulong)py[2])); sum >>= 32;
			pz[3] = (uint)(sum += ((ulong)px[3]) + ((ulong)py[3])); sum >>= 32;
			pz[4] = (uint)(sum += ((ulong)px[4]) + ((ulong)py[4])); sum >>= 32;
			pz[5] = (uint)(sum += ((ulong)px[5]) + ((ulong)py[5])); sum >>= 32;
			pz[6] = (uint)sum;

			if (pz[6] != 0 || CompareTo (pz[0], pz[1], pz[2], pz[3], pz[4], pz[5]) <= 0) {
				carry = ((pz[0] -= P1) > ~P1 ? 1U : 0U);
				tmp = P2 + carry; carry = (tmp < carry | (pz[1] -= tmp) > ~tmp ? 1U : 0U);
				tmp = P3 + carry; carry = (tmp < carry | (pz[2] -= tmp) > ~tmp ? 1U : 0U);
				tmp = P4 + carry; carry = (tmp < carry | (pz[3] -= tmp) > ~tmp ? 1U : 0U);
				tmp = P5 + carry; carry = (tmp < carry | (pz[4] -= tmp) > ~tmp ? 1U : 0U);
				pz[5] -= P6 + carry;
			}
			pz[6] = 0;
			return new Number (pz);
		}

 private PersonalPronoun(Case personalPronounCase, Number number, Person person, string name)
 {
     _case = personalPronounCase;
       _number = number;
       _person = person;
       _name = name;
 }

 public NumberWrapper(Number value)
 {
     if (value != null)
     {
         Value = value.Value;
     }
 }

 private string GetInfix(Person person, Number number)
 {
     switch (_infixType)
       {
     case InfixType.B:
       if (person == Person.First && number == Number.Singular)
       {
     return "bo";
       }
       if (person == Person.Second && number == Number.Singular)
       {
     return "be";
       }
       if (person == Person.Third && number == Number.Plural)
       {
     return "bu";
       }
       return "bi";
     case InfixType.A:
       if (person == Person.First && number == Number.Singular)
       {
     return "a";
       }
       return "e";
     default:
       throw new NotImplementedException();
       }
 }

		private static bool HexNumberToInt32(ref Number.NumberBuffer number, ref int value)
		{
			uint num = 0u;
			bool result = Number.HexNumberToUInt32(ref number, ref num);
			value = (int)num;
			return result;
		}

        /// <summary>
        /// Given an input feature, a feature space and its associated labels, and a positive integer 'k',
        /// Determines the 'k' nearest neighbor label for the input feature. The 'k' value corresponds
        /// to the number of nearest neighbors to use in the voting process.
        /// 
        /// <remarks> 
        /// "When I have this grid of data points, and I provide one additional example row, find the 'k' number
        /// of rows that are most similar, count up the number of occurrences of each label for each row (1 to 'k'), 
        /// and choose the label with the highest occurrence."
        /// </remarks> 
        /// <see href="http://en.wikipedia.org/wiki/K-nearest_neighbor_algorithm" />
        /// </summary>
        /// <param name="distanceType">The type of equation to use when measuring the distance between each data point</param>
        /// <param name="input">The matrix row to input; must have the same number of columns as the feature space</param>
        /// <param name="featureSpace">The feature space matrix; everything we know</param>
        /// <param name="labels">The results for each feature space row; what we call each collection of data points</param>
        /// <param name="k">The number of nearest neighbors to include in the voting; the label with the most occurrences in 'k' neighbors wins</param>
        /// <returns></returns>
        public static string Classify(DistanceType distanceType, Number[] input, Matrix featureSpace, IList<string> labels, int k)
        {
            if (labels.Count() != featureSpace.Rows)
            {
                throw new ArgumentException("The number of labels must match the number of rows of data in the feature space", "labels");
            }

            var distances = CalculateDistances(distanceType, featureSpace, input);

            var nearestNeighbors = distances.OrderByDescending(d => d.Value).Take(k);

            var votes = new Dictionary<string, int>(k);

            foreach (var label in nearestNeighbors.Select(neighbor => labels[neighbor.Key]))
            {
                if (votes.ContainsKey(label))
                {
                    votes[label]++;
                }
                else
                {
                    votes.Add(label, 1);
                }
            }

            var nearest = votes.OrderByDescending(v => v.Value).First().Key;

            return nearest;
        }

		EvaluationCallback GetNumberCallback(Number number)
		{
			EvaluationCallback callback;
			if (m_numbercallbacks.TryGetValue(number, out callback) == true) return callback;

			DynamicMethod method = new DynamicMethod(String.Empty, typeof(Number), new Type[] { typeof(Object) }, typeof(TreeCompiler));
			ILGenerator generator = method.GetILGenerator();

			switch (number.NumberType)
			{
				case NumberType.Int:
					generator.Emit(OpCodes.Ldc_I4, number.IntValue);
					generator.Emit(OpCodes.Newobj, typeof(Number).GetConstructor(new Type[] { typeof(Int32) }));
					break;

				case NumberType.Float:
					generator.Emit(OpCodes.Ldc_R4, number.FloatValue);
					generator.Emit(OpCodes.Newobj, typeof(Number).GetConstructor(new Type[] { typeof(Single) }));
					break;

				default:
					generator.Emit(OpCodes.Ldloc, generator.DeclareLocal(typeof(Number)).LocalIndex);
					break;
			}

			generator.Emit(OpCodes.Ret);

			callback = (EvaluationCallback)method.CreateDelegate(typeof(EvaluationCallback));
			m_numbercallbacks[number] = callback;

			return callback;
		}

        public LiteralNumber(Number numberValue)
        {
            if (numberValue == null)
                throw new ArgumentException("NumberValue is null!");

            NumberValue = numberValue;
        }

 public override BetResult GetResult(Number number)
 {
     if (number.Color == NumberColor.None)
         return BetResult.PARTIAL;
     else
         return number.Color == Color ? BetResult.WIN : BetResult.LOSE;
 }

        public void DoesNotBreakOnDifferentLocale(string locale)
        {
            Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo(locale);

            var number = new Number(1234.5);
            var css = number.ToCss();
            Assert.AreEqual("1234.5", css);
        }