// --------------------------------------------------------------------------------
/// <summary>
/// Returns the result of multiplying the specified Decimal value by negative one.
/// </summary>
/// <param name="d">A DBDecimal.</param>
/// <returns>A Decimal with the value of <c>d</c>, but the opposite sign.</returns>
// --------------------------------------------------------------------------------
public static DBDecimal Negate(DBDecimal d)
{
if (d.IsNull)
{
throw new InvalidOperationException ();
}
return Decimal.Negate (d);
}
// --------------------------------------------------------------------------------
/// <summary>
/// Converts the value of a specified instance of DBDecimal to its equivalent
/// binary representation.
/// </summary>
/// <param name="d">A DBDecimal.</param>
/// <returns>
/// A 32-bit signed integer array with four elements that contain the binary
/// representation of <c>d</c>.
/// </returns>
/// <remarks>
/// <para>
/// The binary representation of a DBDecimal number consists of a 1-bit sign, a
/// 96-bit integer number, and a scaling factor used to divide the integer
/// number and specify what portion of it is a decimal fraction. The scaling
/// factor is implicitly the number 10, raised to an exponent ranging from 0 to 28.
/// </para>
/// <para>
/// The return value is a four-element long array of 32-bit signed integers.
/// </para>
/// <para>
/// The first, second, and third elements of the returned array contain the
/// low, middle, and high 32 bits of the 96-bit integer number.
/// </para>
/// <para>
/// The fourth element of the returned array contains the scale factor and sign.
/// It consists of the following parts:
/// </para>
/// <para>
/// Bits 0 to 15, the lower word, are unused and must be zero.
/// </para>
/// <para>
/// Bits 16 to 23 must contain an exponent between 0 and 28, that indicates the
/// power of 10 to divide the integer number.
/// </para>
/// <para>
/// Bits 24 to 30 are unused and must be zero.
/// </para>
/// <para>
/// Bit 31 contains the sign; 0 meaning positive, and 1 meaning negative.
/// </para>
/// <para>
/// Note that the bit representation differentiates between negative and
/// positive zero. These values are treated as being equal in all operations.
/// </para>
/// </remarks>
/// <exception cref="InvalidOperationException">
/// <c>d</c> has a Null value.
/// </exception>
// --------------------------------------------------------------------------------
public static int[] GetBits(DBDecimal d)
{
if (d.IsNull)
{
throw new InvalidOperationException ();
}
return Decimal.GetBits (d);
}
// --------------------------------------------------------------------------------
/// <summary>
/// Multiplies two specified DBDecimal values.
/// </summary>
/// <param name="d1">A DBDecimal (the multiplicand).</param>
/// <param name="d2">A DBDecimal (the multiplier). </param>
/// <returns>
/// A DBDecimal that is the result of multiplying <c>d1</c> and <c>d2</c>.
/// </returns>
/// <exception cref="OverflowException">
/// The return value is less than <see cref="MinValue"/> or
/// greater than <see cref="MaxValue"/>.
/// </exception>
// --------------------------------------------------------------------------------
public static DBDecimal Multiply(DBDecimal d1, DBDecimal d2)
{
if (d1.IsNull || d2.IsNull)
{
throw new InvalidOperationException ();
}
return Decimal.Multiply (d1, d2);
}
// --------------------------------------------------------------------------------
/// <summary>
/// Returns a value indicating whether two specified instances of Decimal
/// represent the same value.
/// </summary>
/// <param name="d1">A DBDecimal.</param>
/// <param name="d2">A DBDecimal.</param>
/// <returns>true if <c>d1</c> and <c>d2</c> are equal; otherwise, false.</returns>
// --------------------------------------------------------------------------------
public static bool Equals(DBDecimal d1, DBDecimal d2)
{
if (d1.IsNull || d2.IsNull)
{
throw new InvalidOperationException ();
}
return Decimal.Equals (d1, d2);
}
// --------------------------------------------------------------------------------
/// <summary>
/// Rounds a specified Decimal number to the closest integer toward
/// negative infinity.
/// </summary>
/// <param name="value">A DBDecimal.</param>
/// <returns>
/// If <c>d</c> has a fractional part, the next whole DBDecimal number toward
/// negative infinity that is less than <c>d</c>; or if <c>d</c> doesn't have a
/// fractional part, <c>d</c> is returned unchanged.
/// </returns>
/// <exception cref="InvalidOperationException">
/// <c>d</c> has a Null value.
/// </exception>
// --------------------------------------------------------------------------------
public static DBDecimal Floor(DBDecimal value)
{
if (value.IsNull)
{
throw new InvalidOperationException ();
}
return Decimal.Floor (value);
}
// --------------------------------------------------------------------------------
/// <summary>
/// Divides two specified Decimal values.
/// </summary>
/// <param name="d1">A DBDecimal (the divident).</param>
/// <param name="d2">A DBDecimal (the divisor).</param>
/// <returns>
/// The DBDecimal that is the result of dividing <c>d1</c> by <c>d2</c>.
/// </returns>
/// <exception cref="DivideByZeroException">
/// <c>d2</c> is zero.
/// </exception>
/// <exception cref="InvalidOperationException">
/// Either <c>d1</c> or <c>d2</c> has a Null value.
/// </exception>
/// <exception cref="OverflowException">
/// The return value is less than <see cref="MinValue"/> or
/// greater than <see cref="MaxValue"/>.
/// </exception>
// --------------------------------------------------------------------------------
public static DBDecimal Divide(DBDecimal d1, DBDecimal d2)
{
if (d1.IsNull || d2.IsNull)
{
throw new InvalidOperationException ();
}
return Decimal.Divide (d1, d2);
}
// --------------------------------------------------------------------------------
/// <summary>
/// Converts the specified DBDecimal value to the equivalent OLE Automation
/// Currency value, which is contained in a 64-bit signed integer.
/// </summary>
/// <param name="value">A DBDecimal value.</param>
/// <returns>A 64-bit signed integer that contains the OLE Automation equivalent
/// of <c>value</c>.</returns>
// --------------------------------------------------------------------------------
public static long ToOACurrency(DBDecimal value)
{
if (value.IsNull)
{
return 0;
}
return DBDecimal.ToOACurrency (value);
}
// --------------------------------------------------------------------------------
/// <summary>
/// Subtracts one specified DBDecimal value from another.
/// </summary>
/// <param name="d1">A DBDecimal (the minuend).</param>
/// <param name="d2">A DBDecimal (the subtrahend). </param>
/// <returns>
/// The DBDecimal result of subtracting <c>d2</c> from <c>d1</c>.
/// </returns>
/// <exception cref="InvalidOperationException">
/// Either <c>d1</c> or <c>d2</c> has a Null value.
/// </exception>
/// <exception cref="OverflowException">
/// The sum of <c>d1</c> and <c>d2</c> is less than <see cref="MinValue"/> or
/// greater than <see cref="MaxValue"/>.
/// </exception>
// --------------------------------------------------------------------------------
public static DBDecimal Subtract(DBDecimal d1, DBDecimal d2)
{
if (d1.IsNull || d2.IsNull)
{
throw new InvalidOperationException ();
}
return Decimal.Subtract (d1, d2);
}
// --------------------------------------------------------------------------------
/// <summary>
/// Rounds a DBDecimal value to a specified number of decimal places.
/// </summary>
/// <param name="d">A DBDecimal value to round.</param>
/// <param name="decimals">
/// A value from 0 to 28 that specifies the number of decimal places to round to.
/// </param>
/// <returns>
/// The DBDecimal number equivalent to d rounded to decimals number of decimal
/// places.
/// </returns>
/// <exception cref="ArgumentOutOfRangeException">
/// <c>decimals</c> is not a value from 0 to 28.
/// </exception>
// --------------------------------------------------------------------------------
public static DBDecimal Round(DBDecimal d, int decimals)
{
if (d.IsNull)
{
throw new InvalidOperationException ();
}
return Decimal.Round (d, decimals);
}
// --------------------------------------------------------------------------------
/// <summary>
/// Computes the remainder after dividing two Decimal values.
/// </summary>
/// <param name="d1">A DBDecimal (the divident).</param>
/// <param name="d2">A DBDecimal (the divisor).</param>
/// <returns>
/// The DBDecimal that is the remainder of dividing <c>d1</c> by <c>d2</c>.
/// </returns>
/// <exception cref="DivideByZeroException">
/// <c>d2</c> is zero.
/// </exception>
/// <exception cref="InvalidOperationException">
/// Either <c>d1</c> or <c>d2</c> has a Null value.
/// </exception>
/// <exception cref="OverflowException">
/// The return value is less than <see cref="MinValue"/> or
/// greater than <see cref="MaxValue"/>.
/// </exception>
// --------------------------------------------------------------------------------
public static DBDecimal Remainder(DBDecimal d1, DBDecimal d2)
{
if (d1.IsNull || d2.IsNull)
{
throw new InvalidOperationException ();
}
return Decimal.Remainder (d1, d2);
}