53Decimal result = new Decimal ();

349return new Decimal(d.lo, d.mid, d.hi, d.flags & ~SignMask); 600return new Decimal(lo,mid,hi,flags); 760return new Decimal(d.lo, d.mid, d.hi, d.flags ^ SignMask); 1015return new Decimal(value); 1020return new Decimal(value); 1024return new Decimal(value); 1029return new Decimal(value); 1033return new Decimal(value); 1037return new Decimal(value); 1042return new Decimal(value); 1046return new Decimal(value); 1051return new Decimal(value); 1056return new Decimal(value); 1060return new Decimal(value);

314return new Decimal(decimalArray);

648return new Decimal(bits);

29dec = new System.Decimal((int) low, (int)mid, (int)hi, (sign != 0), scale); 40dec = new System.Decimal(low, mid, hi, (sign != 0), scale); 81return new System.Decimal(low, mid, hi, (sign != 0), scale); 92return new System.Decimal(low, mid, hi, (sign != 0), scale);

235Decimal from = new Decimal(); 236Decimal to = new Decimal(); 237Decimal accumulated = new Decimal(); 238Decimal foundation = new Decimal();

3232bamlType.DefaultConstructor = delegate() { return new System.Decimal(); };

780return new Decimal(

662return new Decimal(buffer);

202return new Decimal(_value._numericInfo.data1, _value._numericInfo.data2, _value._numericInfo.data3, !_value._numericInfo.positive, _value._numericInfo.scale); 211return new Decimal((int)(l & 0xffffffff), (int)(l >> 32), 0, isNegative, 4);

23public static readonly Decimal SQL_SMALL_MONEY_MIN = new Decimal(-214748.3648); 24public static readonly Decimal SQL_SMALL_MONEY_MAX = new Decimal(214748.3647);

1137return new Decimal((int)m_data1, (int)m_data2, (int)m_data3, !IsPositive, m_bScale); 1155return new SqlDecimal(new Decimal(x));

128public SqlMoney(double value) : this(new Decimal(value)) { 173return new Decimal(unchecked((int)value), unchecked((int)(value >> 32)), 0, fNegative, (byte)x_iMoneyScale); 234return new SqlMoney(new Decimal(x));

1330return new Decimal(lo, mi, hi, value._sign < 0, 0);

194value = new Decimal(bits);

4486return new Decimal(longVal); 4508return new Decimal(longVal);

1492pageCounter.Minimum = new Decimal(0d); 1493pageCounter.Maximum = new Decimal(1000d);

428return new Decimal((int)m_data1, (int)m_data2, (int)m_data3, !IsPositive, m_bScale); 562return new Decimal(unchecked((int)v), unchecked((int)(v >> 32)), 0, neg, MoneyScale);

3278return new Decimal(ValueAsLong()); 3281return new Decimal(ValueAsULong()); 3284return new Decimal(GetSingle(this.tokDataPos)); 3287return new Decimal(GetDouble(this.tokDataPos));

4798return new Decimal(longVal); 4820return new Decimal(longVal);

57typeof(Decimal),

296Decimal IConvertible.ToDecimal(IFormatProvider provider) {

249Decimal IConvertible.ToDecimal(IFormatProvider provider) {

494Decimal IConvertible.ToDecimal(IFormatProvider provider) {

131(RuntimeType)typeof(Decimal), 682return Decimal.ToSByte(Decimal.Round(value, 0)); 785return Decimal.ToByte(Decimal.Round(value, 0)); 884return Decimal.ToInt16(Decimal.Round(value, 0)); 996return Decimal.ToUInt16(Decimal.Round(value, 0)); 1109return Decimal.FCallToInt32(value); 1224return Decimal.ToUInt32(Decimal.Round(value, 0)); 1317return Decimal.ToInt64(Decimal.Round(value, 0)); 1423return Decimal.ToUInt64(Decimal.Round(value, 0)); 1685return Decimal.Parse(value, CultureInfo.CurrentCulture); 1688public static Decimal ToDecimal(String value, IFormatProvider provider) { 1691return Decimal.Parse(value, NumberStyles.Number, provider); 1944public static string ToString(Decimal value, IFormatProvider provider) {

20public Currency(Decimal value) { 21m_value = Decimal.ToCurrency(value).m_value; 51public static Decimal ToDecimal(Currency c) 53Decimal result = new Decimal (); 61private static extern void FCallToDecimal(ref Decimal result,Currency c);

1639Decimal IConvertible.ToDecimal(IFormatProvider provider) {

68, IComparable<Decimal>, IEquatable<Decimal> { 109public const Decimal Zero = 0m; 112public const Decimal One = 1m; 115public const Decimal MinusOne = -1m; 119public const Decimal MaxValue = 79228162514264337593543950335m; 123public const Decimal MinValue = -79228162514264337593543950335m; 128private const Decimal NearNegativeZero = -0.000000000000000000000000001m; 132private const Decimal NearPositiveZero = +0.000000000000000000000000001m; 232Decimal temp = Currency.ToDecimal(value); 241public static long ToOACurrency(Decimal value) 246public static Decimal FromOACurrency(long cy) 348internal static Decimal Abs(Decimal d) { 355public static Decimal Add(Decimal d1, Decimal d2) 368private static extern void FCallAddSub(ref Decimal d1, ref Decimal d2, byte bSign); 373private static extern void FCallAddSubOverflowed(ref Decimal d1, ref Decimal d2, byte bSign, ref bool overflowed); 377public static Decimal Ceiling(Decimal d) { 378return (-(Decimal.Floor(-d))); 387public static int Compare(Decimal d1, Decimal d2) { 395private static extern int FCallCompare(ref Decimal d1, ref Decimal d2); 408if (!(value is Decimal)) 411Decimal other = (Decimal)value; 416public int CompareTo(Decimal value) 424public static Decimal Divide(Decimal d1, Decimal d2) 436private static extern void FCallDivide(ref Decimal d1, ref Decimal d2); 441private static extern void FCallDivideOverflowed(ref Decimal d1, ref Decimal d2, ref bool overflowed); 450if (value is Decimal) { 451Decimal other = (Decimal)value; 458public bool Equals(Decimal value) 474public static bool Equals(Decimal d1, Decimal d2) { 482public static Decimal Floor(Decimal d) 491private static extern void FCallFloor(ref Decimal d); 530public static Decimal Parse(String s) { 534public static Decimal Parse(String s, NumberStyles style) { 539public static Decimal Parse(String s, IFormatProvider provider) { 543public static Decimal Parse(String s, NumberStyles style, IFormatProvider provider) { 548public static Boolean TryParse(String s, out Decimal result) { 552public static Boolean TryParse(String s, NumberStyles style, IFormatProvider provider, out Decimal result) { 567public static int[] GetBits(Decimal d) { 571internal static void GetBytes(Decimal d, byte [] buffer) { 608private static void InternalAddUInt32RawUnchecked(ref Decimal value, UInt32 i) { 627private static UInt32 InternalDivRemUInt32(ref Decimal value, UInt32 divisor) { 650private static void InternalRoundFromZero(ref Decimal d, int decimalCount) { 679internal static Decimal Max(Decimal d1, Decimal d2) { 687internal static Decimal Min(Decimal d1, Decimal d2) { 691public static Decimal Remainder(Decimal d1, Decimal d2) { 712Decimal dividedResult = Truncate(d1/d2); 713Decimal multipliedResult = dividedResult * d2; 714Decimal result = d1 - multipliedResult; 737public static Decimal Multiply(Decimal d1, Decimal d2) 749private static extern void FCallMultiply(ref Decimal d1, ref Decimal d2); 754private static extern void FCallMultiplyOverflowed(ref Decimal d1, ref Decimal d2, ref bool overflowed); 759public static Decimal Negate(Decimal d) { 771public static Decimal Round(Decimal d) { 776public static Decimal Round(Decimal d, int decimals) 782public static Decimal Round(Decimal d, MidpointRounding mode) { 787public static Decimal Round(Decimal d, int decimals, MidpointRounding mode) { 807private static extern void FCallRound(ref Decimal d, int decimals); 812public static Decimal Subtract(Decimal d1, Decimal d2) 822public static byte ToByte(Decimal value) { 840public static sbyte ToSByte(Decimal value) { 856public static short ToInt16(Decimal value) { 874internal static Currency ToCurrency(Decimal d) 884private static extern void FCallToCurrency(ref Currency result, Decimal d); 892public static extern double ToDouble(Decimal d); 897internal static extern int FCallToInt32(Decimal d); 904public static int ToInt32(Decimal d) { 924public static long ToInt64(Decimal d) { 944public static ushort ToUInt16(Decimal value) { 962public static uint ToUInt32(Decimal d) { 978public static ulong ToUInt64(Decimal d) { 994public static extern float ToSingle(Decimal d); 1001public static Decimal Truncate(Decimal d) 1011private static extern void FCallTruncate(ref Decimal d); 1014public static implicit operator Decimal(byte value) { 1019public static implicit operator Decimal(sbyte value) { 1023public static implicit operator Decimal(short value) { 1028public static implicit operator Decimal(ushort value) { 1032public static implicit operator Decimal(char value) { 1036public static implicit operator Decimal(int value) { 1041public static implicit operator Decimal(uint value) { 1045public static implicit operator Decimal(long value) { 1050public static implicit operator Decimal(ulong value) { 1055public static explicit operator Decimal(float value) { 1059public static explicit operator Decimal(double value) { 1063public static explicit operator byte(Decimal value) { 1068public static explicit operator sbyte(Decimal value) { 1072public static explicit operator char(Decimal value) { 1083public static explicit operator short(Decimal value) { 1088public static explicit operator ushort(Decimal value) { 1092public static explicit operator int(Decimal value) { 1097public static explicit operator uint(Decimal value) { 1101public static explicit operator long(Decimal value) { 1106public static explicit operator ulong(Decimal value) { 1110public static explicit operator float(Decimal value) { 1114public static explicit operator double(Decimal value) { 1118public static Decimal operator +(Decimal d) { 1122public static Decimal operator -(Decimal d) { 1126public static Decimal operator ++(Decimal d) { 1130public static Decimal operator --(Decimal d) { 1135public static Decimal operator +(Decimal d1, Decimal d2) { 1141public static Decimal operator -(Decimal d1, Decimal d2) { 1147public static Decimal operator *(Decimal d1, Decimal d2) { 1153public static Decimal operator /(Decimal d1, Decimal d2) { 1158public static Decimal operator %(Decimal d1, Decimal d2) { 1163public static bool operator ==(Decimal d1, Decimal d2) { 1168public static bool operator !=(Decimal d1, Decimal d2) { 1173public static bool operator <(Decimal d1, Decimal d2) { 1178public static bool operator <=(Decimal d1, Decimal d2) { 1183public static bool operator >(Decimal d1, Decimal d2) { 1188public static bool operator >=(Decimal d1, Decimal d2) { 1262Decimal IConvertible.ToDecimal(IFormatProvider provider) {

953: TraceLoggingTypeInfo<Decimal>

765else if (dataType == typeof(Decimal))

363Decimal IConvertible.ToDecimal(IFormatProvider provider) {

1024Decimal IConvertible.ToDecimal(IFormatProvider provider)

65Decimal ToDecimal(IFormatProvider provider);

262Decimal IConvertible.ToDecimal(IFormatProvider provider) {

235Decimal IConvertible.ToDecimal(IFormatProvider provider) {

214Decimal IConvertible.ToDecimal(IFormatProvider provider) {

100NullableHelper<Decimal>(); 114new List<Decimal>(); 138SZArrayHelper<Decimal>(null);

236return Decimal.ToDecimal(m_buffer);

251Decimal.GetBytes(value,_buffer);

279public virtual void Write(Decimal value) { 742public override void Write(Decimal value) {

307public Decimal ReadDecimal(Int64 position) { 308int sizeOfType = sizeof(Decimal); 795public void Write(Int64 position, Decimal value) { 796int sizeOfType = sizeof(Decimal); 800Decimal.GetBytes(value, decimalArray);

57public static Decimal Ceiling(Decimal d) { 58return Decimal.Ceiling(d); 76public static Decimal Floor(Decimal d) { 77return Decimal.Floor(d); 155public static Decimal Round(Decimal d) { 156return Decimal.Round(d,0); 159public static Decimal Round(Decimal d, int decimals) { 160return Decimal.Round(d,decimals); 163public static Decimal Round(Decimal d, MidpointRounding mode) { 164return Decimal.Round(d, 0, mode); 167public static Decimal Round(Decimal d, int decimals, MidpointRounding mode) { 168return Decimal.Round(d, decimals, mode); 176public static Decimal Truncate(Decimal d) { 177return Decimal.Truncate(d); 334public static Decimal Abs(Decimal value) 336return Decimal.Abs(value); 417public static Decimal Max(Decimal val1, Decimal val2) { 418return Decimal.Max(val1,val2); 499public static Decimal Min(Decimal val1, Decimal val2) { 500return Decimal.Min(val1,val2); 593public static int Sign(Decimal value)

296public static extern String FormatDecimal(Decimal value, String format, NumberFormatInfo info); 325public unsafe static extern Boolean NumberBufferToDecimal(byte* number, ref Decimal value); 649internal unsafe static Decimal ParseDecimal(String value, NumberStyles options, NumberFormatInfo numfmt) { 653Decimal result = 0; 1048internal unsafe static Boolean TryParseDecimal(String value, NumberStyles options, NumberFormatInfo numfmt, out Decimal result) {

644else if (type == typeof(Decimal)) {

557else if (type == typeof (Decimal)) 659writer.Write((Decimal) value);

778(typeof(TResult) == typeof(Decimal) && default(Decimal) == (Decimal)(object)result) ||

44public System.Decimal Value 52internal static Decimal GetRawDecimalConstant(CustomAttributeData attr) 62return (Decimal)namedArgument.TypedValue.Value; 96private System.Decimal dec;

24public CurrencyWrapper(Decimal obj) 31if (!(obj is Decimal)) 33m_WrappedObject = (Decimal)obj; 36public Decimal WrappedObject 44private Decimal m_WrappedObject;

49[FieldOffset(0)] private Decimal _decimal; 570public Decimal AsDecimal { 589public Decimal AsCy { 592return Decimal.FromOACurrency(_typeUnion._unionTypes._cy); 597_typeUnion._unionTypes._cy = Decimal.ToOACurrency(value);

1062Decimal _value; 1082public SoapInteger (Decimal value) 1084_value = Decimal.Truncate(value); 1088public Decimal Value 1091set {_value = Decimal.Truncate(value);} 1103return new SoapInteger(Decimal.Parse(value, NumberStyles.Integer, CultureInfo.InvariantCulture)); 1112Decimal _value; 1133public SoapPositiveInteger (Decimal value) 1135_value = Decimal.Truncate(value); 1136if (_value < Decimal.One) 1144public Decimal Value 1148_value = Decimal.Truncate(value); 1149if (_value < Decimal.One) 1166return new SoapPositiveInteger(Decimal.Parse(value, NumberStyles.Integer, CultureInfo.InvariantCulture)); 1175Decimal _value; 1195public SoapNonPositiveInteger (Decimal value) 1197_value = Decimal.Truncate(value); 1198if (_value > Decimal.Zero) 1206public Decimal Value 1210_value = Decimal.Truncate(value); 1211if (_value > Decimal.Zero) 1228return new SoapNonPositiveInteger(Decimal.Parse(value, NumberStyles.Integer, CultureInfo.InvariantCulture)); 1237Decimal _value; 1257public SoapNonNegativeInteger (Decimal value) 1259_value = Decimal.Truncate(value); 1260if (_value < Decimal.Zero) 1268public Decimal Value 1272_value = Decimal.Truncate(value); 1273if (_value < Decimal.Zero) 1290return new SoapNonNegativeInteger(Decimal.Parse(value, NumberStyles.Integer, CultureInfo.InvariantCulture)); 1299Decimal _value; 1319public SoapNegativeInteger (Decimal value) 1321_value = Decimal.Truncate(value); 1322if (value > Decimal.MinusOne) 1330public Decimal Value 1334_value = Decimal.Truncate(value); 1335if (_value > Decimal.MinusOne) 1352return new SoapNegativeInteger(Decimal.Parse(value, NumberStyles.Integer, CultureInfo.InvariantCulture));

107protected abstract void WriteDecimal(Decimal val, String name); 161} else if (varType==typeof(Decimal)) {

144public Decimal ToDecimal(Object value) {

292array = new Decimal[length]; 495internal static Type typeofDecimal = typeof(Decimal); 520internal static Type typeofDecimalArray = typeof(Decimal[]);

98internal void WriteDecimal(Decimal value)

315internal Decimal ReadDecimal() 317return Decimal.Parse(dataReader.ReadString(), CultureInfo.InvariantCulture);

38Decimal ToDecimal(Object value);

270Decimal IConvertible.ToDecimal(IFormatProvider provider) {

333Decimal IConvertible.ToDecimal(IFormatProvider provider) {

3425Decimal IConvertible.ToDecimal(IFormatProvider provider) {

1897static internal extern void DecimalCanonicalizeInternal(ref Decimal dec);

237Decimal IConvertible.ToDecimal(IFormatProvider provider) {

219Decimal IConvertible.ToDecimal(IFormatProvider provider) {

214Decimal IConvertible.ToDecimal(IFormatProvider provider) {

110typeof(Decimal), 260public Variant(Decimal val) {

225else if (typeof(Decimal).IsAssignableFrom(type))

5502case KnownElements.Decimal: t = typeof(Decimal); break;

28internal static Decimal InterpolateDecimal(Decimal from, Decimal to, Double progress) 30return from + ((to - from) * (Decimal)progress); 167internal static Decimal AddDecimal(Decimal value1, Decimal value2) 269internal static Decimal SubtractDecimal(Decimal value1, Decimal value2) 391internal static Double GetSegmentLengthDecimal(Decimal from, Decimal to) 517internal static Decimal ScaleDecimal(Decimal value, Double factor) 519return value * (Decimal)factor; 625internal static bool IsValidAnimationValueDecimal(Decimal value) 767internal static Decimal GetZeroValueDecimal(Decimal baseValue) 769return Decimal.Zero;

313else if (typeof(Decimal) == type) 317else if (typeof(Decimal[]) == type)

45private Decimal[] _keyValues; 60Type typeofProp = typeof(Decimal?); 69new PropertyMetadata((Decimal?)null, propCallback), 76new PropertyMetadata((Decimal?)null, propCallback), 83new PropertyMetadata((Decimal?)null, propCallback), 107public DecimalAnimation(Decimal toValue, Duration duration) 119public DecimalAnimation(Decimal toValue, Duration duration, FillBehavior fillBehavior) 132public DecimalAnimation(Decimal fromValue, Decimal toValue, Duration duration) 145public DecimalAnimation(Decimal fromValue, Decimal toValue, Duration duration, FillBehavior fillBehavior) 218protected override Decimal GetCurrentValueCore(Decimal defaultOriginValue, Decimal defaultDestinationValue, AnimationClock animationClock) 235Decimal from = new Decimal(); 236Decimal to = new Decimal(); 237Decimal accumulated = new Decimal(); 238Decimal foundation = new Decimal(); 352Decimal accumulator = AnimatedTypeHelpers.SubtractDecimal(to, from); 377_keyValues = new Decimal[2]; 384_keyValues = new Decimal[2]; 391_keyValues = new Decimal[1]; 398_keyValues = new Decimal[1]; 404_keyValues = new Decimal[1]; 425Decimal? typedValue = (Decimal?)value; 445public Decimal? From 449return (Decimal?)GetValue(FromProperty); 465public Decimal? To 469return (Decimal?)GetValue(ToProperty); 485public Decimal? By 489return (Decimal?)GetValue(ByProperty);

103return GetCurrentValue((Decimal)defaultOriginValue, (Decimal)defaultDestinationValue, animationClock); 115return typeof(Decimal); 152public Decimal GetCurrentValue(Decimal defaultOriginValue, Decimal defaultDestinationValue, AnimationClock animationClock) 215protected abstract Decimal GetCurrentValueCore(Decimal defaultOriginValue, Decimal defaultDestinationValue, AnimationClock animationClock);

331protected sealed override Decimal GetCurrentValueCore( 332Decimal defaultOriginValue, 333Decimal defaultDestinationValue, 359Decimal currentIterationValue; 395Decimal fromValue; 643private Decimal GetResolvedKeyFrameValue(Int32 resolvedKeyFrameIndex) 954Decimal prevKeyValue = _keyFrames[index - 1].Value; 958Decimal currentKeyValue = _keyFrames[index].Value;

356public DiscreteDecimalKeyFrame(Decimal value) 364public DiscreteDecimalKeyFrame(Decimal value, KeyTime keyTime) 392protected override Decimal InterpolateValueCore(Decimal baseValue, double keyFrameProgress)

301public EasingDecimalKeyFrame(Decimal value) 310public EasingDecimalKeyFrame(Decimal value, KeyTime keyTime) 320public EasingDecimalKeyFrame(Decimal value, KeyTime keyTime, IEasingFunction easingFunction) 349protected override Decimal InterpolateValueCore(Decimal baseValue, double keyFrameProgress)

624protected DecimalKeyFrame(Decimal value) 633protected DecimalKeyFrame(Decimal value, KeyTime keyTime) 676typeof(Decimal), 691Value = (Decimal)value; 698public Decimal Value 702return (Decimal)GetValue(ValueProperty); 719public Decimal InterpolateValue( 720Decimal baseValue, 740protected abstract Decimal InterpolateValueCore( 741Decimal baseValue,

205public LinearDecimalKeyFrame(Decimal value) 213public LinearDecimalKeyFrame(Decimal value, KeyTime keyTime) 239protected override Decimal InterpolateValueCore(Decimal baseValue, double keyFrameProgress)

317public SplineDecimalKeyFrame(Decimal value) 326public SplineDecimalKeyFrame(Decimal value, KeyTime keyTime) 336public SplineDecimalKeyFrame(Decimal value, KeyTime keyTime, KeySpline keySpline) 370protected override Decimal InterpolateValueCore(Decimal baseValue, double keyFrameProgress)

537typeof(Decimal),typeof(Boolean),

218case 126: t = () => typeof(Decimal); break;

3230typeof(System.Decimal),

5670case KnownElements.Decimal: t = typeof(System.Decimal); break;

1249else if (e.Value is Decimal) { 1250GenerateDecimalValue((Decimal)e.Value); 2038private void GenerateDecimalValue(Decimal d) {

1249protected override void GenerateDecimalValue(Decimal d) {

1526else if (e.Value is Decimal) { 1527GenerateDecimalValue((Decimal)e.Value); 1559protected virtual void GenerateDecimalValue(Decimal d) {

21/// <para>Provides a type converter to convert <see cref='System.Decimal'/> 43return typeof(Decimal); 70if (destinationType == typeof(InstanceDescriptor) && value is Decimal) { 72object[] args = new object[] { Decimal.GetBits((Decimal)value) }; 73MemberInfo member = typeof(Decimal).GetConstructor(new Type[] {typeof(Int32[])}); 98return Decimal.Parse(value, NumberStyles.Float, formatInfo); 106return Decimal.Parse(value, culture); 113return ((Decimal)value).ToString("G", formatInfo);

137temp[typeof(Decimal)] = typeof(DecimalConverter);

393else if (t == typeof(Decimal))

66typeof(Decimal),

469public RemoteArgument(System.Decimal value) 477public RemoteArgument(System.Decimal value, bool isByRef) 1009public System.Decimal DecimalValue 1017return default(System.Decimal); 1023return (System.Decimal)this._value;

534if (type == typeof(Decimal)) {

54case TypeCode.Decimal: return new PrimitiveParameterExpression<Decimal>(name);

954if (Decimal.Truncate(value) == value) { 956int intValue = Decimal.ToInt32(value); 958il.EmitNew(typeof(Decimal).GetConstructor(new Type[] { typeof(int) })); 960long longValue = Decimal.ToInt64(value); 962il.EmitNew(typeof(Decimal).GetConstructor(new Type[] { typeof(long) })); 972int[] bits = Decimal.GetBits(value); 1039il.Emit(OpCodes.Newobj, typeof(Decimal).GetConstructor(new Type[] { typeof(int) }));

47Decimal GetDecimal( int ordinal );

46void SetDecimal( int ordinal, Decimal value );

98ht.Add( typeof( System.Decimal ), ExtendedClrTypeCode.Decimal ); 271if (value.GetType() == typeof( Decimal )) 298else if (value.GetType() == typeof( Decimal )) 691SqlDecimal value = (SqlDecimal)(Decimal)obj;

80internal static readonly SqlMoney MaxSmallMoney = new SqlMoney( ( (Decimal)Int32.MaxValue ) / 10000 ); 81internal static readonly SqlMoney MinSmallMoney = new SqlMoney( ( (Decimal)Int32.MinValue ) / 10000 );

222public virtual Decimal GetDecimal( int ordinal ) { 575public virtual void SetDecimal( int ordinal, Decimal value ) {

280public virtual Decimal GetDecimal( int ordinal ) { 633public virtual void SetDecimal( int ordinal, Decimal value ) {

204public virtual Decimal GetDecimal(int ordinal) { 463public virtual void SetDecimal(int ordinal, Decimal value) {

223internal static Decimal GetDecimal( SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData ) { 232return (Decimal) result; 1416internal static void SetDecimal( SmiEventSink_Default sink, ITypedSettersV3 setters, int ordinal, SmiMetaData metaData, Decimal value ) { 1600case ExtendedClrTypeCode.Decimal: SetDecimal_PossiblyMoney( sink, setters, ordinal, metaData, (Decimal) value ); break; 2393private static Decimal GetDecimal_PossiblyMoney(SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData) { 2405private static void SetDecimal_PossiblyMoney(SmiEventSink_Default sink, ITypedSettersV3 setters, int ordinal, SmiMetaData metaData, Decimal value) { 3311private static void SetDecimal_Unchecked( SmiEventSink_Default sink, ITypedSettersV3 setters, int ordinal, Decimal value ) {

30typeof(Decimal),

1581static internal ArgumentException ParameterValueOutOfRange(Decimal value) {

86else if (type == typeof(Decimal)) { return checked((Decimal)value); }

269public override Decimal GetDecimal(int i) { 270return((Decimal) _values[i]);

86typeof(Decimal),

124abstract public Decimal GetDecimal(int ordinal);

55public abstract Decimal GetDecimal(int i);

18private static readonly Decimal defaultValue = Decimal.Zero; 20private Decimal[] values; 23: base(column, typeof(Decimal), defaultValue, StorageType.Decimal) { 31Decimal sum = defaultValue; 44Decimal meanSum = (Decimal)defaultValue; 48checked { meanSum += (Decimal)values[record];} 54Decimal mean; 55checked {mean = (meanSum /(Decimal) meanCount);} 97Decimal min = Decimal.MaxValue; 111Decimal max = Decimal.MinValue; 136throw ExprException.Overflow(typeof(Decimal)); 142Decimal valueNo1 = values[recordNo1]; 143Decimal valueNo2 = values[recordNo2]; 150return Decimal.Compare(valueNo1, valueNo2); // InternalCall 161Decimal valueNo1 = values[recordNo]; 165return Decimal.Compare(valueNo1, (Decimal)value); 202Decimal[] newValues = new Decimal[capacity]; 215return XmlConvert.ToString((Decimal)value); 219return new Decimal[recordCount]; 223Decimal[] typedStore = (Decimal[]) store; 229values = (Decimal[]) store;

44Decimal meanSum = (Decimal)defaultValue; 48checked { meanSum += (Decimal)values[record];} 55checked {mean = (Int64)(Decimal)(meanSum / (Decimal) meanCount);}

520return ((IConvertible)(Decimal)value).ToString(formatProvider); 767return XmlConvert.ToString((Decimal) value);

44Decimal meanSum = (Decimal)defaultValue; 48checked { meanSum += (Decimal)values[record];} 55checked {mean = (UInt64)(Decimal)(meanSum / (Decimal)meanCount);}

1562return ((dataType == typeof(Int32)) || (dataType == typeof(Int64)) || (dataType == typeof(Int16)) || (dataType == typeof(Decimal)) || (dataType == typeof(System.Numerics.BigInteger)) ||

3311sequence.MaxOccurs = Decimal.MaxValue; 3555if (((XmlSchemaSequence)ct.Particle).MaxOccurs == Decimal.MaxValue) 3559else if (any0.MaxOccurs == Decimal.MaxValue)

5922any.MaxOccurs = Decimal.MaxValue;

426override public Decimal GetDecimal (int ordinal) { 430return (Decimal) currentDataRow[ordinal];

150return Decimal.Compare(Convert.ToDecimal(vLeft, FormatProvider), Convert.ToDecimal(vRight, FormatProvider));

110if (Decimal.TryParse(sval, NumberStyles.Number, NumberFormatInfo.InvariantInfo, out r12)) {

444return SqlConvert.ChangeType2((decimal) SqlConvert.ChangeType2(argumentValues[0], StorageType.Decimal, typeof(Decimal), FormatProvider), mytype, type, FormatProvider);

86value = -(Decimal) vl;

58Decimal GetDecimal(int i);

783static private readonly TypeMap _Decimal = new TypeMap(OdbcType.Decimal, DbType.Decimal, typeof(Decimal), ODBC32.SQL_TYPE.DECIMAL, ODBC32.SQL_C.NUMERIC, ODBC32.SQL_C.NUMERIC, 19, ADP.DecimalMaxPrecision28, false); 790static private readonly TypeMap _Numeric = new TypeMap(OdbcType.Numeric, DbType.Decimal, typeof(Decimal), ODBC32.SQL_TYPE.NUMERIC, ODBC32.SQL_C.NUMERIC, ODBC32.SQL_C.NUMERIC, 19, ADP.DecimalMaxPrecision28, false);

751this.dataCache[i] = Decimal.Parse(s, System.Globalization.CultureInfo.InvariantCulture);

487if ((null == value) || (value is Decimal) || Convert.IsDBNull(value)) { // MDAC 60882 506byte s = (byte)((Decimal.GetBits((Decimal)value)[3] & 0x00ff0000) >> 0x10); 597value = ((Decimal)value).ToString(CultureInfo.CurrentCulture); 714if ((ODBC32.SQL_PARAM.INPUT_OUTPUT == sqldirection) && (value is Decimal)) { 858Value = Decimal.Parse((string)Value, System.Globalization.CultureInfo.CurrentCulture);

305WriteNumeric(offset, (Decimal)value, checked((byte)sizeorprecision));

306value = (Decimal) Value_UI8(); // UInt64->Decimal 426Value_CY((Decimal) value); 450Value_DECIMAL((Decimal) value); 483if (value is Decimal) { 484Value_UI8(Convert.ToUInt64((Decimal)value, CultureInfo.InvariantCulture)); 508Value_NUMERIC((Decimal) value); 715private Decimal Value_CY() { 718return Decimal.FromOACurrency(RowBinding.ReadInt64(ValueOffset)); 720private void Value_CY(Decimal value) { 724RowBinding.WriteInt64(ValueOffset, Decimal.ToOACurrency(value)); 775private Decimal Value_DECIMAL() { 787private void Value_DECIMAL(Decimal value) { 799int[] tmp = Decimal.GetBits(value); 959private Decimal Value_NUMERIC() { 964private void Value_NUMERIC(Decimal value) { 1228internal Decimal ValueDecimal() { 1229Decimal value; 1243value = (Decimal)Value_UI8(); 1246value = (Decimal) ValueVariant();

162static private readonly NativeDBType D_Currency = new NativeDBType( 19, 8, true, false, OleDbType.Currency, NativeDBType.CY, S_CY, typeof(System.Decimal), NativeDBType.CY, DbType.Currency ); // 4 - integer8 167static private readonly NativeDBType D_Decimal = new NativeDBType( 28, 16, true, false, OleDbType.Decimal, NativeDBType.DECIMAL, S_DECIMAL, typeof(System.Decimal), NativeDBType.DECIMAL, DbType.Decimal ); // 9 - (tagDec) // MDAC 68447 179static private readonly NativeDBType D_Numeric = new NativeDBType( 28, 19, true, false, OleDbType.Numeric, NativeDBType.NUMERIC, S_NUMERIC, typeof(System.Decimal), NativeDBType.NUMERIC, DbType.Decimal ); // 21 - (tagDB_Numeric) 187static private readonly NativeDBType D_UnsignedBigInt = new NativeDBType( 20, 8, true, false, OleDbType.UnsignedBigInt, NativeDBType.UI8, S_UI8, typeof(System.Decimal), NativeDBType.UI8, DbType.UInt64 ); // 28 - unsigned integer8 191static private readonly NativeDBType D_VarNumeric = new NativeDBType( 255, 16, true, false, OleDbType.VarNumeric, NativeDBType.VARNUMERIC, S_VARNUMERIC, typeof(System.Decimal), NativeDBType.DECIMAL, DbType.VarNumeric); // 32 - (unicode pointer)

908override public Decimal GetDecimal(int ordinal) {

417value = Decimal.Parse((string)value, NumberStyles.Currency, (IFormatProvider)null); // WebData 99376

149case VarEnum.VT_CY: return typeof(System.Decimal); 157case VarEnum.VT_DECIMAL: return typeof(System.Decimal);

647internal Decimal ReadNumeric(int offset) { 665internal void WriteNumeric(int offset, Decimal value, byte precision) { 666int[] tmp = Decimal.GetBits(value);

236if (value is Decimal) { 237return ((System.Data.SqlTypes.SqlDecimal)(Decimal) value).Precision; // WebData 102913 243if (value is Decimal) { 244return (byte)((Decimal.GetBits((Decimal)value)[3] & 0x00ff0000) >> 0x10);

1053case TypeCode.Decimal: value = this.Adjust((Decimal)value); break; 1140SqlDecimal sd = new SqlDecimal((Decimal)value); 1454private static readonly SqlMoney x_smSmallMax = new SqlMoney(((Decimal)Int32.MaxValue)/10000); 1455private static readonly SqlMoney x_smSmallMin = new SqlMoney(((Decimal)Int32.MinValue)/10000);

194internal Decimal Decimal { 213return (Decimal)this.Value; // anything else we haven't thought of goes through boxing. 765case SqlBuffer.StorageType.Decimal: return typeof(Decimal); 770case SqlBuffer.StorageType.Money: return typeof(Decimal);

977return new SqlDecimal((Decimal)currentRowValue); 1088if (typeof(SqlDecimal) == t || typeof(Decimal) == t) { 1355sqlValue = new SqlDecimal((Decimal)value);

2249override public Decimal GetDecimal(int i) {

275public override Decimal GetDecimal(int ordinal) {

518else if (comVal is Decimal) 519sqlVal = new SqlDecimal((Decimal)comVal); 785(38, 4, 17, true, false, false, TdsEnums.SQLNUMERICN, TdsEnums.SQLNUMERICN, MetaTypeName.DECIMAL, typeof(System.Decimal), typeof(SqlDecimal), SqlDbType.Decimal, DbType.Decimal, 2); 797(19, 255, 8, true, false, false, TdsEnums.SQLMONEY, TdsEnums.SQLMONEYN, MetaTypeName.MONEY, typeof(System.Decimal), typeof(SqlMoney), SqlDbType.Money, DbType.Currency, 0); 800(10, 255, 4, true, false, false, TdsEnums.SQLMONEY4, TdsEnums.SQLMONEYN, MetaTypeName.SMALLMONEY, typeof(System.Decimal), typeof(SqlMoney), SqlDbType.SmallMoney, DbType.Currency, 0);

944value = Decimal.Parse((string)value, NumberStyles.Currency, (IFormatProvider)null); // WebData 99376

23public static readonly Decimal SQL_SMALL_MONEY_MIN = new Decimal(-214748.3648); 24public static readonly Decimal SQL_SMALL_MONEY_MAX = new Decimal(214748.3647);

5937WriteCurrency((Decimal)value, 8, stateObj); 5944stateObj.WriteByte((byte)((Decimal.GetBits((Decimal)value)[3] & 0x00ff0000) >> 0x10)); // propbytes: scale 5945WriteDecimal((Decimal)value, stateObj); 6098WriteCurrency((Decimal)value, 8, stateObj); 6106stateObj.WriteByte((byte)((Decimal.GetBits((Decimal)value)[3] & 0x00ff0000) >> 0x10)); // propbytes: scale 6107WriteDecimal((Decimal)value, stateObj); 6160int[] bits = Decimal.GetBits(value.Value); 6170Decimal decimalValue = value.Value; 6185private byte[] SerializeCurrency(Decimal value, int length, TdsParserStateObject stateObj) { 6187int[] bits = Decimal.GetBits(m.Value); 6224private void WriteCurrency(Decimal value, int length, TdsParserStateObject stateObj) { 6226int[] bits = Decimal.GetBits(m.Value); 6392int oldScale = (Decimal.GetBits(value)[3] & 0x00ff0000) >> 0x10; 6447int[] decimalBits = Decimal.GetBits(value); 6496stateObj._decimalBits = Decimal.GetBits(value); 8228value = AdjustDecimalScale((Decimal)value, scale); 8230SqlDecimal sqlValue = new SqlDecimal((Decimal)value); 8235throw ADP.ParameterValueOutOfRange((Decimal)value); 10649WriteDecimal((Decimal)value, stateObj); 10672WriteCurrency((Decimal)value, type.FixedLength, stateObj); 10837return SerializeDecimal((Decimal)value, stateObj); 10882return SerializeCurrency((Decimal)value, type.FixedLength, stateObj);

491public SqlDecimal(Decimal value) { 503int[] bits = Decimal.GetBits(value); 819public Decimal Value { 1130private Decimal ToDecimal() { 1144public static implicit operator SqlDecimal(Decimal x) { 1162public static explicit operator Decimal(SqlDecimal x) {

104public SqlMoney(Decimal value) { 150public Decimal Value { 162public Decimal ToDecimal() { 216return Decimal.ToDouble(ToDecimal()); 223public static implicit operator SqlMoney(Decimal x) { 241public static explicit operator Decimal(SqlMoney x) { 252Decimal money = ToDecimal(); 264Decimal d; 279else if (Decimal.TryParse(s, SqlNumberStyle, NumberFormatInfo.InvariantInfo, out d)) { 283money = new SqlMoney(Decimal.Parse(s, NumberStyles.Currency, NumberFormatInfo.CurrentInfo)); 334 new SqlMoney(Decimal.Multiply(x.ToDecimal(), y.ToDecimal())); 342 new SqlMoney(Decimal.Divide(x.ToDecimal(), y.ToDecimal())); 421return x.IsNull ? Null : new SqlMoney(Decimal.Parse(x.Value,NumberStyles.Currency,null));

227new NameType("fixed.14.4" , typeof(Decimal) ), /* XDR */ 240new NameType("number" , typeof(Decimal) ), /* XDR */

212if (type == typeof(Decimal)|| type == typeof(SqlDecimal) || type == typeof(SqlMoney))

475if (isChoice && pt.MaxOccurs > Decimal.One && (((XmlSchemaElement)el).SchemaType is XmlSchemaComplexType)) // we know frominference condition 479if (!FromInference || (((XmlSchemaElement)el).MaxOccurs != Decimal.One && !(((XmlSchemaElement)el).SchemaType is XmlSchemaComplexType))) 778if (this.FromInference && pt is XmlSchemaChoice && pt.MaxOccurs > Decimal.One && (el.SchemaType is XmlSchemaComplexType)) 2290if ((((XmlSchemaElement)el).MaxOccurs != Decimal.One ) && (!isComplexTypeOrValidElementType)) { 2310if (((XmlSchemaParticle)el).MaxOccurs > Decimal.One && (((XmlSchemaElement)choiceEl).SchemaType is XmlSchemaComplexType)) // amir 2312if ((((XmlSchemaElement)choiceEl).RefName.Name.Length != 0) && (!FromInference && ((XmlSchemaElement)choiceEl).MaxOccurs != Decimal.One && !(((XmlSchemaElement)choiceEl).SchemaType is XmlSchemaComplexType)))

299public override Decimal GetDecimal(int ordinal) 301return ((Decimal)_values[ordinal]);

311Decimal value; 312if (!Decimal.TryParse(numberPart, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out value))

222if (value is Decimal) { 223return ((System.Data.SqlTypes.SqlDecimal)(Decimal) value).Precision; 229if (value is Decimal) { 230return (byte)((Decimal.GetBits((Decimal)value)[3] & 0x00ff0000) >> 0x10);

202Decimal temp; 203if (!Decimal.TryParse(text, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out temp))

62typeDefaultMap[PrimitiveTypeKind.Decimal] = default(Decimal);

212primitiveTypes[(int)PrimitiveTypeKind.Decimal] = CreatePrimitiveType(typeof(Decimal), PrimitiveTypeKind.Decimal);

161InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.Decimal], PrimitiveTypeKind.Decimal, EdmConstants.Decimal, typeof(Decimal));

754protected internal static Decimal SetValidValue(Decimal value, string propertyName) 768protected internal static Decimal SetValidValue(Decimal value) 786protected internal static Nullable<Decimal> SetValidValue(Nullable<Decimal> value, string propertyName) 802protected internal static Nullable<Decimal> SetValidValue(Nullable<Decimal> value)

832typeof(Decimal).GetMethod("Floor", BindingFlags.Public | BindingFlags.Static, null, new Type[] { typeof(decimal) }, null), 833typeof(Decimal).GetMethod("Ceiling", BindingFlags.Public | BindingFlags.Static, null, new Type[] { typeof(decimal) }, null), 834typeof(Decimal).GetMethod("Round", BindingFlags.Public | BindingFlags.Static, null, new Type[] { typeof(decimal) }, null), 835typeof(Decimal).GetMethod("Round", BindingFlags.Public | BindingFlags.Static, null, new Type[] { typeof(decimal), typeof(int) }, null),

35public static System.Double? StandardDeviation(IEnumerable<System.Decimal> collection) 37ObjectQuery<System.Decimal> objectQuerySource = collection as ObjectQuery<System.Decimal>; 49public static System.Double? StandardDeviation(IEnumerable<System.Decimal?> collection) 51ObjectQuery<System.Decimal?> objectQuerySource = collection as ObjectQuery<System.Decimal?>; 147public static System.Double? StandardDeviationP(IEnumerable<System.Decimal> collection) 149ObjectQuery<System.Decimal> objectQuerySource = collection as ObjectQuery<System.Decimal>; 161public static System.Double? StandardDeviationP(IEnumerable<System.Decimal?> collection) 163ObjectQuery<System.Decimal?> objectQuerySource = collection as ObjectQuery<System.Decimal?>; 259public static System.Double? Var(IEnumerable<System.Decimal> collection) 261ObjectQuery<System.Decimal> objectQuerySource = collection as ObjectQuery<System.Decimal>; 273public static System.Double? Var(IEnumerable<System.Decimal?> collection) 275ObjectQuery<System.Decimal?> objectQuerySource = collection as ObjectQuery<System.Decimal?>; 371public static System.Double? VarP(IEnumerable<System.Decimal> collection) 373ObjectQuery<System.Decimal> objectQuerySource = collection as ObjectQuery<System.Decimal>; 385public static System.Double? VarP(IEnumerable<System.Decimal?> collection) 387ObjectQuery<System.Decimal?> objectQuerySource = collection as ObjectQuery<System.Decimal?>; 1008public static System.Decimal? Truncate(System.Decimal? value, System.Int32? digits)

235override public Decimal GetDecimal(int ordinal) 237return (Decimal)GetValue(ordinal); 430public void SetDecimal(int ordinal, Decimal value)

178override public Decimal GetDecimal(int ordinal) 180return (Decimal)GetValue(ordinal);

220public static System.String StringConvert(System.Decimal? number) 238public static System.String StringConvert(System.Decimal? number, System.Int32? length) 256public static System.String StringConvert(System.Decimal? number, System.Int32? length, System.Int32? decimalArg) 293public static System.Double? Acos(System.Decimal? arg1) 311public static System.Double? Asin(System.Decimal? arg) 329public static System.Double? Atan(System.Decimal? arg) 347public static System.Double? Atan2(System.Decimal? arg1, System.Decimal? arg2) 365public static System.Double? Cos(System.Decimal? arg) 383public static System.Double? Cot(System.Decimal? arg) 410public static System.Decimal? Degrees(System.Decimal? arg1) 437public static System.Double? Exp(System.Decimal? arg) 455public static System.Double? Log(System.Decimal? arg) 473public static System.Double? Log10(System.Decimal? arg) 509public static System.Decimal? Radians(System.Decimal? arg) 563public static System.Decimal? Sign(System.Decimal? arg) 581public static System.Double? Sin(System.Decimal? arg) 608public static System.Double? SquareRoot(System.Decimal? arg) 626public static System.Double? Square(System.Decimal? arg1) 644public static System.Double? Tan(System.Decimal? arg) 941public static System.Int32? DataLength(System.Decimal? arg) 1022public static System.Int32? Checksum(System.Decimal? arg1) 1103public static System.Int32? Checksum(System.Decimal? arg1, System.Decimal? arg2) 1184public static System.Int32? Checksum(System.Decimal? arg1, System.Decimal? arg2, System.Decimal? arg3)

681override public Decimal GetDecimal(int ordinal) {

544override public Decimal GetDecimal(int ordinal) { 545return (Decimal)GetValue(ordinal);

964string strDecimal = ((Decimal)e.Value).ToString(CultureInfo.InvariantCulture);

1391int scale = (Decimal.GetBits(d)[3] & 0x00FF0000) >> 16;

159else if (value.GetType() == typeof(Decimal)) 450else if (typeof(Decimal) == targetType) 462if (Decimal.TryParse(text, NumberStyles.Float, NumberFormatInfo.InvariantInfo, out result)) 468targetValue = default(Decimal); 475targetValue = default(Decimal); 534else if (typeof(Decimal) == targetType) 639else if (typeof(Decimal) == valueType)

134else if (propertyType == typeof(Decimal) ||

341else if (typeof(Decimal) == value.GetType()) 343this.writer.WriteValue((Decimal)value);

76new KeyValuePair<Type, string>(typeof(Decimal), XmlConstants.EdmDecimalTypeName), 77new KeyValuePair<Type, string>(typeof(Decimal?), XmlConstants.EdmDecimalTypeName),

159else if (value.GetType() == typeof(Decimal)) 639else if (typeof(Decimal) == valueType)

321return XmlConvert.ToString((Decimal)propertyValue); 470types[(int)StorageType.Decimal] = typeof(Decimal); 503named.Add(XmlConstants.EdmDecimalTypeName, typeof(Decimal));

916int[] bits = Decimal.GetBits(dec);

130nd = f.LiteralDecimal(Decimal.Parse(ReadText(), CultureInfo.InvariantCulture));

141cmp = Decimal.Compare(this.decVal, that.decVal);

217parameter is Single || parameter is Decimal

380public override Decimal ReadContentAsDecimal() 382return (Decimal)_reader.ReadContentAs( typeof( Decimal ), null );

172return Decimal.FromOACurrency(BitConverter.ToInt64(newBytes, 0)); 316else if (obj is Decimal) 319byte[] bytes = BitConverter.GetBytes(Decimal.ToOACurrency((Decimal)obj));

500public BigInteger(Decimal value) 503int[] bits = Decimal.GetBits(Decimal.Truncate(value)); 1186public static explicit operator BigInteger(Decimal value) 1316public static explicit operator Decimal(BigInteger value) 1320return (Decimal)value._sign;

251public static explicit operator Complex(Decimal value) {

81internal static Type typeofDecimal = typeof(Decimal);

760type = typeof(Decimal);

89if (Decimal.TryParse(value, NumberStyles.Float, NumberFormatInfo.InvariantInfo, out decimalValue)) 94if (decimalValue == Decimal.Zero)

730any.MaxOccurs = Decimal.MaxValue;

813if (any.MaxOccurs != Decimal.MaxValue)

369public Decimal ToDecimal()

1730public override Decimal ReadContentAsDecimal()

1699public override Decimal ReadContentAsDecimal() 1702return (Decimal)reader.ReadContentAs(typeof(Decimal), null);

398element.MaxOccurs = Decimal.MaxValue;

754value = new Decimal[0]; 916writer.WriteValue((Decimal)value);

132return Decimal.FromOACurrency(BitConverter.ToInt64(bytes, 0)); 309else if (obj is Decimal) 311byte[] bytes = BitConverter.GetBytes(Decimal.ToOACurrency((Decimal)obj));

339result = (T)(object)(Decimal)sbyteSource; 374result = (T)(object)(Decimal)byteSource; 397result = (T)(object)(Decimal)int16Source; 426result = (T)(object)(Decimal)uint16Source; 446result = (T)(object)(Decimal)int32Source; 472result = (T)(object)(Decimal)uint32Source; 489result = (T)(object)(Decimal)int64Source; 506result = (T)(object)(Decimal)uint64Source; 538result = (T)(object)(Decimal)charSource;

42this.defaultSupportedQueryStringTypes.Add(typeof(Decimal), null); 109return parameter == null ? default(Decimal) : XmlConvert.ToDecimal(parameter);

165t=typeof(Decimal);

61else if (typeof(Decimal).IsAssignableFrom(toType)) { 110else if (typeof(Decimal).IsAssignableFrom(fromType)) { 111return ((Decimal)value).ToString(formatString, CultureInfo.InvariantCulture);

512(type == typeof(Decimal)));

252value = Decimal.Parse(cleanInput, CultureInfo.InvariantCulture); 421compareResult = ((Decimal)leftObject).CompareTo(rightObject);

529(type == typeof(Decimal)));

94(type == typeof(Decimal)) ||

69else if (value is Decimal) { 71int[] bits = Decimal.GetBits((Decimal)value);

2046 else if(value is Decimal) 2048 return (double)((Decimal)value);

929 type == typeof(Decimal) ||

31typeNameToTypeCode[typeof(Decimal)] = TypeCode.Decimal;

334return typeof(Decimal); 399return typeof(Decimal); 532if (type.IsAssignableFrom(typeof(Decimal)) && Decimal.TryParse(s, out decimalResult))

465if (o.GetType().IsPrimitive || o is Decimal) {

71else if (type == typeof(Decimal)) {

409t == typeof(void) || t == typeof(System.Decimal) || t == typeof(Guid) ||

613typeof(Decimal),

890(type == typeof(Decimal)));

975return typeof(Decimal);

1475dataType.Equals(typeof(Decimal)) ||

501preferredSize = new Size(0, Math.Min(img.Height, Decimal.ToInt32((decimal)img.Height * imgWidthAllowed / img.Width))); 513preferredSize = new Size(0, Math.Min(ico.Height, Decimal.ToInt32((decimal)ico.Height * icoWidthAllowed / ico.Width))); 536preferredSize = new Size(Math.Min(img.Width, Decimal.ToInt32((decimal)img.Width * imgHeightAllowed / img.Height)), 0); 548preferredSize = new Size(Math.Min(ico.Width, Decimal.ToInt32((decimal)ico.Width * icoHeightAllowed / ico.Height)), 0); 650imgBounds = new Rectangle(bounds.X, bounds.Y, Decimal.ToInt32((decimal)imgWidth * bounds.Height / imgHeight), bounds.Height); 655imgBounds = new Rectangle(bounds.X, bounds.Y, bounds.Width, Decimal.ToInt32((decimal)imgHeight * bounds.Width / imgWidth));

4330else if (t == typeof(Decimal)) { 4332Decimal c = (Decimal)var; 4334v.SetLong(Decimal.ToInt64(c)); 4338Decimal d = Convert.ToDecimal(var, CultureInfo.InvariantCulture); 4339v.SetLong(Decimal.ToInt64(d));

35private static readonly Decimal DefaultValue = Decimal.Zero; 36private static readonly Decimal DefaultMinimum = Decimal.Zero; 37private static readonly Decimal DefaultMaximum = (Decimal)100.0; 39private static readonly Decimal DefaultIncrement = Decimal.One; 57private Decimal increment = DefaultIncrement; 63private Decimal minimum = DefaultMinimum; 64private Decimal maximum = DefaultMaximum; 70private Decimal currentValue = DefaultValue; 183public Decimal Increment { 194if (value < (Decimal)0.0) { 213public Decimal Maximum { 240public Decimal Minimum { 362public Decimal Value { 422private Decimal Constrain(Decimal value) { 456Decimal newValue = currentValue; 611Value = Constrain(Decimal.Parse(Text, CultureInfo.CurrentCulture)); 729Decimal newValue = currentValue;

18private Decimal increment; // Ideally we would use UInt32 but NumericUpDown uses Decimal values. 20public NumericUpDownAcceleration(Int32 seconds, Decimal increment) 27if (increment < Decimal.Zero) 59public Decimal Increment { 68if (value < Decimal.Zero)

2046 else if(value is Decimal) 2048 return (double)((Decimal)value);

929 type == typeof(Decimal) ||

424public Decimal ToDecimal() { 549public Decimal ToDecimal() { 566Decimal money = ToDecimal();

2901Type TypeOfDecimal = typeof(System.Decimal); 3248Decimal v = ValueAsDecimal(); 3267Decimal ValueAsDecimal() { 3793Decimal v = (Decimal)GetUInt64(this.tokDataPos);

733public override Decimal ReadElementContentAsDecimal() {

916value = Decimal.Negate(value); //Need to compare maxValue allowed against the absolute value 918while (Decimal.Truncate(value) != value) { //Till it has a fraction

2389if (copyElement.MinOccurs != Decimal.One && this.Occurrence == InferenceOption.Relaxed) 2393if (copyElement.MaxOccurs != Decimal.One) {

1088ConstructorInfo Decimal_ctor = typeof(Decimal).GetConstructor( 1094int[] bits = Decimal.GetBits((decimal)o);

81WriteElementStringRaw(@"decimal", @"", System.Xml.XmlConvert.ToString((System.Decimal)((System.Decimal)o)));

3108Writer.Write(((Decimal)value).ToString(null, NumberFormatInfo.InvariantInfo));

644public static string ToString(Decimal value) { 867public static Decimal ToDecimal (string s) { 868return Decimal.Parse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowDecimalPoint|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo); 872internal static Exception TryToDecimal(string s, out Decimal result) { 873if (!Decimal.TryParse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowDecimalPoint|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) { 879internal static Decimal ToInteger (string s) { 880return Decimal.Parse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo); 883internal static Exception TryToInteger(string s, out Decimal result) { 884if (!Decimal.TryParse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {

106if (value is Decimal) return (double)(Decimal)value;

225else if (typeof(Decimal).IsAssignableFrom(type)) 309else if (type == typeof(Decimal)) 409else if (typeof(Decimal).IsAssignableFrom(type))