public static UBigInt DivRem(UBigInt u, UBigInt v, out UBigInt r)
{
var q_handle = EngineObject.DivRem(u.Handle, v.Handle, out Core.UBigIntHandle r_handle);
r = new UBigInt(r_handle);
return(new UBigInt(q_handle));
}
public BigInt Divide(UBigInt v)
{
Core.BigIntHandle r;
var q = EngineObject.DivRem(Handle, v.Handle, out r);
return(new BigInt(q));
}
/// <summary>
/// 拡張ユークリッド互除法を使用して、不定方程式 a * x + b * y = GCD(a, b), a > 0, b > 0 を満たす x および y を求めます。
/// この数値は変数 a として使用されます。
/// </summary>
/// <param name="b">不定方程式の変数 b です。</param>
/// <returns>
/// 計算結果を表す<see cref="Tuple{UBigInt, BigInt, BigInt}"/>オブジェクトです。
/// オブジェクトの第一要素は a と b の最大公約数、第二要素は不定方程式における変数 x、第三要素は不定方程式における変数 y です。
/// </returns>
public Tuple <UBigInt, BigInt, BigInt> ExtendedEuclideanAlgorithm(UBigInt b)
{
var a = this;
if (a.IsZero)
{
throw new ArgumentOutOfRangeException();
}
if (b.IsZero)
{
throw new ArgumentOutOfRangeException();
}
var previous_x = BigInt.One;
var previous_y = BigInt.Zero;
var current_x = BigInt.Zero;
var current_y = BigInt.One;
while (!b.IsZero)
{
UBigInt next_b;
var q = a.DivRem(b, out next_b);
var next_x = previous_x - q * current_x;
var next_y = previous_y - q * current_y;
a = b;
b = next_b;
previous_x = current_x;
current_x = next_x;
previous_y = current_y;
current_y = next_y;
}
return(new Tuple <UBigInt, BigInt, BigInt>(a, previous_x, previous_y));
}
public BigInt DivRem(BigInt v, out UBigInt r)
{
var q_hadnle = BigInt.EngineObject.DivRem(Handle, v.Handle, out Core.UBigIntHandle r_handle);
r = new UBigInt(r_handle);
return(new BigInt(q_hadnle));
}
public static UInt64 Divide(this UInt64 u, UBigInt v)
{
UInt64 r;
var q = UBigInt.EngineObject.DivRem(u, v.Handle, out r);
return(q);
}
public UBigInt DivRem(UBigInt v, out UBigInt r)
{
Core.UBigIntHandle r_handle;
var q_handle = EngineObject.DivRem(Handle, v.Handle, out r_handle);
r = new UBigInt(r_handle);
return(new UBigInt(q_handle));
}
public static BigInt DivRem(BigInt u, UBigInt v, out BigInt r)
{
Core.BigIntHandle r_handle;
var q_handle = EngineObject.DivRem(u.Handle, v.Handle, out r_handle);
r = new BigInt(r_handle);
return(new BigInt(q_handle));
}
public static UBigInt ToUBigInt(this BigInteger x)
{
bool negative;
var x_array = ToBigInt(x, out negative);
if (negative)
{
throw new OverflowException();
}
var value = UBigInt.FromByteArray(x_array);
return(value);
}
public static bool TryParse(string value, NumberStyles style, IFormatProvider provider, out UBigInt result)
{
if (provider as NumberFormatInfo == null)
{
provider = CultureInfo.CurrentCulture.NumberFormat;
}
Core.UBigIntHandle r;
if (!EngineObject.TryParse(value, style, provider as NumberFormatInfo, out r))
{
result = UBigInt.Zero;
return(false);
}
result = new UBigInt(r);
return(true);
}
public UBigInt BitwiseAnd(UBigInt v)
{
return(new UBigInt(EngineObject.BitwiseAnd(Handle, v.Handle)));
}
public BigInt Subtruct(UBigInt v)
{
return(new BigInt(EngineObject.Subtruct(Handle, v.Handle)));
}
public BigInt Add(UBigInt v)
{
return(new BigInt(EngineObject.Add(Handle, v.Handle)));
}
public static UBigInt ExclusiveOr(this UInt64 u, UBigInt v)
{
return(new UBigInt(UBigInt.EngineObject.ExclusiveOr(u, v.Handle)));
}
public static UBigInt Add(this UInt64 u, UBigInt v)
{
return(new UBigInt(UBigInt.EngineObject.Add(u, v.Handle)));
}
public static UBigInt GreatestCommonDivisor(this UInt64 u, UBigInt v)
{
return(new UBigInt(UBigInt.EngineObject.GreatestCommonDivisor(u, v.Handle)));
}
public static BigInt DivRem(Int64 u, UBigInt v, out Int64 r)
{
var q_handle = BigInt.EngineObject.DivRem(u, v.Handle, out r);
return(new BigInt(q_handle));
}
public static UInt64 Subtruct(this UInt64 u, UBigInt v)
{
return(UBigInt.EngineObject.Subtruct(u, v.Handle));
}
public static bool Equals(UBigInt u, Int64 v)
{
return(BigInt.EngineObject.Equals(u.Handle, v));
}
public static Rational From(UBigInt x)
{
return(new Rational(EngineObject.From(x.Handle)));
}
public static UBigInt Multiply(this UInt64 u, UBigInt v)
{
return(new UBigInt(UBigInt.EngineObject.Multiply(u, v.Handle)));
}
public static bool Equals(Int64 u, UBigInt v)
{
return(BigInt.EngineObject.Equals(u, v.Handle));
}
public static UInt32 Remainder(this UInt32 u, UBigInt v)
{
return(UBigInt.EngineObject.Remainder(u, v.Handle));
}
public static bool Equals(UBigInt u, UBigInt v)
{
return(EngineObject.Equals(u.Handle, v.Handle));
}
public int CompareTo(UBigInt v)
{
return(EngineObject.Compare(Handle, v.Handle));
}
public static UInt64 DivRem(UInt64 u, UBigInt v, out UInt64 r)
{
var q = EngineObject.DivRem(u, v.Handle, out r);
return(q);
}
public static int Compare(UBigInt u, UBigInt v)
{
return(EngineObject.Compare(u.Handle, v.Handle));
}
public static UBigInt DivRem(UBigInt u, UInt64 v, out UInt64 r)
{
var q = EngineObject.DivRem(u.Handle, v, out r);
return(new UBigInt(q));
}
public Rational Add(UBigInt v)
{
return(new Rational(EngineObject.Add(Handle, v.Handle)));
}
public static BigInt DivRem(UBigInt u, Int64 v, out UInt64 r)
{
var q_handle = BigInt.EngineObject.DivRem(u.Handle, v, out r);
return(new BigInt(q_handle));
}
public UBigInt ExclusiveOr(UBigInt v)
{
return(new UBigInt(EngineObject.ExclusiveOr(Handle, v.Handle)));
}
