public ArithmeticCalculator(IAdder <T> adder, ISubtractor <T> subtractor, IMultiplier <T> multiplier, IDivider <T> divider)
{
_adder = adder;
_subtractor = subtractor;
_multiplier = multiplier;
_divider = divider;
}
public Calculator(IQueryParser queryParser, IMultiplier multipler, IAdder adder, ISubtractor subtractor, IDivider divider)
{
_queryParser = queryParser;
_multiplier = multipler;
_adder = adder;
_subtractor = subtractor;
_divider = divider;
}
public Calculator(IAdder adder, ISubtractor subtractor, IDivider divider, IMultiplier multiplier, IExponenter exponenter)
{
this.adder = adder;
this.subtractor = subtractor;
this.divider = divider;
this.multiplier = multiplier;
this.exponenter = exponenter;
}
public Application(
IMultiplier multiplier,
IMultiplicationResultFormatter formatter
)
{
this.multiplier = multiplier;
this.formatter = formatter;
}
public ApplicationFacade(IMultiplier multiplier, IEnumerable <IOutputFormatter> formatters)
{
_multiplier = multiplier;
foreach (IOutputFormatter outputFormatter in formatters)
{
_formattersDictionary.Add(outputFormatter.Format, outputFormatter);
}
}
// .cctor
static MultiplyManager()
{
// Create new classic multiplier instance
IMultiplier classicMultiplier = new ClassicMultiplier();
// Fill publicity visible multiplier fields
ClassicMultiplier = classicMultiplier;
AutoFhtMultiplier = new AutoFhtMultiplier(classicMultiplier);
}
// .cctor
static MultiplyManager()
{
// Create new classic multiplier instance
IMultiplier classicMultiplier = new ClassicMultiplier();
// Fill publicity visible multiplier fields
ClassicMultiplier = classicMultiplier;
AutoFhtMultiplier = new AutoFhtMultiplier(classicMultiplier);
}
public void CollectGrowable(GrowableIncarnation growable)
{
if (growable.CanCollect())
{
IMultiplier multiplier = rules.ActiveFinalMultiplierForIdentifiable(growable.Entity);
BigInteger amount = multiplier.Apply(growable.Entity.GrownResource.Amount);
state.AddResource(growable.Entity.GrownResource.Resource.Entity, amount);
growable.Reset();
}
}
/// <summary>
/// Returns a specified big integer raised to the specified power.
/// </summary>
/// <param name="value">Number to raise.</param>
/// <param name="power">Power.</param>
/// <param name="multiplyMode">Multiply mode set explicitly.</param>
/// <returns>Number in given power.</returns>
/// <exception cref="ArgumentNullException"><paramref name="value" /> is a null reference.</exception>
static public IntX Pow(IntX value, uint power, MultiplyMode multiplyMode)
{
// Exception
if (ReferenceEquals(value, null))
{
throw new ArgumentNullException("value");
}
// Return one for zero pow
if (power == 0)
{
return(1);
}
// Return the number itself from a power of one
if (power == 1)
{
return(new IntX(value));
}
// Return zero for a zero
if (value._length == 0)
{
return(new IntX());
}
// Get first one bit
int msb = Bits.Msb(power);
// Get multiplier
IMultiplier multiplier = MultiplyManager.GetMultiplier(multiplyMode);
// Do actual raising
IntX res = value;
for (uint powerMask = 1U << (msb - 1); powerMask != 0; powerMask >>= 1)
{
// Always square
res = multiplier.Multiply(res, res);
// Maybe mul
if ((power & powerMask) != 0)
{
res = multiplier.Multiply(res, value);
}
}
return(res);
}
public BaseExerciseModel(IExerciseConfiguration config, IExerciseInitVO initVO, ILogger logger)
{
_logger = logger;
ExerciseConfiguration = config;
ExerciseInitVO = initVO;
_exerciseSettings = initVO.Settings;
// Init the property changes for tracking
_propertiesUpdates = new Dictionary <Type, IModelPropertyUpdateVO>();
_totalGoodRuns = 0;
TotalRuns = 0;
_currentGoodRuns = 0;
_currentBadRuns = 0;
GoodRunsInARow = 0;
_warmUpRoundsCounter = 1;
_warmUpEnabeld = initVO.WarmUpEnabled;
_startDifficulty = (initVO.StartDifficulty > ExerciseConfiguration.MaxDifficulty) ? ExerciseConfiguration.MaxDifficulty : initVO.StartDifficulty;
#pragma warning disable RECS0021 // Warns about calls to virtual member functions occuring in the constructor
_multiplier = InitMultiplier(_startDifficulty, ExerciseConfiguration);
#pragma warning restore RECS0021 // Warns about calls to virtual member functions occuring in the constructor
// listen to multiplier changes
_multiplier.OnChanged += OnMultiplierChanged;
#pragma warning disable RECS0021 // Warns about calls to virtual member functions occuring in the constructor
_bonusScore = GetScoreForStartingDifficulty(_startDifficulty);
#pragma warning restore RECS0021 // Warns about calls to virtual member functions occuring in the constructor
_currentDifficulty = _startDifficulty;
AddPropertyUpdate(new BadRunsToLevelDownUpdateVO(ExerciseConfiguration.GetBadRunsByLevel(_startDifficulty), ExerciseConfiguration.GetBadRunsByLevel(_startDifficulty)));
AddPropertyUpdate(new GoodRunsToLevelUpUpdateVO(ExerciseConfiguration.GetGoodRunsByLevel(_startDifficulty), ExerciseConfiguration.GetGoodRunsByLevel(_startDifficulty)));
AddPropertyUpdate(new DifficultyUpdateVO(_startDifficulty, _startDifficulty));
AddPropertyUpdate(new MaxDifficultyUpdateVO(ExerciseConfiguration.MaxDifficulty, ExerciseConfiguration.MaxDifficulty));
_warmUpState = _warmUpEnabeld && (ExerciseConfiguration.GetWarmUpRoundsByLevel(_currentDifficulty) > 0)?WarmUpState.Enabled:WarmUpState.Disabled;
if (_warmUpState == WarmUpState.Enabled)
{
var originalValue = ExerciseConfiguration.GetWarmUpRoundsByLevel(_currentDifficulty);
AddPropertyUpdate(new WarmUpUpdateVO(originalValue, originalValue, originalValue));
}
_lastRoundLevelChange = LevelState.NEW;
}
public IReadOnlyCollection <TestMethodInstance> Explode(IMultiplier testMethodMultiplier)
{
var result = new List <TestMethodInstance>();
// get the class instance
var classInstance = GetClassInstance(Method.ReflectedType);
var param = FindParameters(classInstance);
// do the param fit in the method ?
var infos = Method.GetParameters();
IEnumerable <object[]> enumerable = param as IList <object[]> ?? param.ToList();
var nbParamFromDataProvider = NbParamFromDataProvider(enumerable);
if (infos.Count() != nbParamFromDataProvider)
{
throw new DataProviderException("expected " + infos.Count() + " parameters but got " + nbParamFromDataProvider);
}
return(GetMethodInstance(enumerable, result, classInstance, testMethodMultiplier));
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
if ((this._parent.SlUnits == null))
{
ISlUnits slUnitsCasted = item.As <ISlUnits>();
if ((slUnitsCasted != null))
{
this._parent.SlUnits = slUnitsCasted;
return;
}
}
if ((this._parent.Multiplier == null))
{
IMultiplier multiplierCasted = item.As <IMultiplier>();
if ((multiplierCasted != null))
{
this._parent.Multiplier = multiplierCasted;
return;
}
}
}
public void ExecuteSkill(bool isKeyDown)
{
var canCastSkill = Time.time >= _cd;
if (canCastSkill && _plyJump.IsGrounded)
{
if (_isSkillActive && !isKeyDown)
{
_isSkillActive = false;
_rb.constraints = RigidbodyConstraints2D.None | RigidbodyConstraints2D.FreezeRotation;
_anim.SetTrigger("Shoot");
var projectilePrefab = TrySpawnProjectile();
float chargeTimePassedHalved = (Time.time - _startChargeTime) / 2 + 0.25f;
float chargedAmount = chargeTimePassedHalved * ChargeRate;
float charged = chargedAmount < 10 ? chargedAmount : 10;
if (projectilePrefab)
{
projectilePrefab.transform.localScale = new Vector3(charged, charged, charged);
IMultiplier multiplier = projectilePrefab.GetComponent <IMultiplier>();
multiplier.SetMultiplier(charged * 3);
}
_cd = Time.time + Cooldown;
}
else if (!_isSkillActive && isKeyDown)
{
_isSkillActive = true;
_rb.constraints = RigidbodyConstraints2D.FreezeAll;
_anim.SetTrigger("StartCharge");
_startChargeTime = Time.time;
}
}
}
public WebTestMethodExploder(MethodInfo method, Configuration config) : base(method)
{
_multiplier = new WebTestMultiplier(config);
}
public MultiplicationController(IMultiplier multiplier)
{
_multiplier = multiplier;
}
public MultiplyController(ILogger <MultiplyController> logger, IMultiplier multiplier)
{
_logger = logger;
_multiplier = multiplier;
}
public BeforeSuiteWebTestMethodExploder(MethodInfo method, Configuration config) : base(method)
{
_beforeSuiteWebTestMethodMultiplier = new BeforeSuiteWebTestMethodMultiplier(config);
}
public AfterSuiteWebTestMethodExploder(MethodInfo method, Configuration config)
: base(method)
{
_afterSuiteWebTestMethodMultiplier = new AfterSuiteWebTestMethodMultiplier(config);
}
/// <summary>
/// Converts digits from internal representaion into given base.
/// </summary>
/// <param name="digits">Big integer digits.</param>
/// <param name="length">Big integer length.</param>
/// <param name="numberBase">Base to use for output.</param>
/// <param name="outputLength">Calculated output length (will be corrected inside).</param>
/// <returns>Conversion result (later will be transformed to string).</returns>
override unsafe public uint[] ToString(uint[] digits, uint length, uint numberBase, ref uint outputLength)
{
uint[] outputArray = base.ToString(digits, length, numberBase, ref outputLength);
// Maybe base method already converted this number
if (outputArray != null)
{
return(outputArray);
}
// Check length - maybe use classic converter instead
if (length < Constants.FastConvertLengthLowerBound || length > Constants.FastConvertLengthUpperBound)
{
return(_classicStringConverter.ToString(digits, length, numberBase, ref outputLength));
}
int resultLengthLog2 = Bits.CeilLog2(outputLength);
uint resultLength = 1U << resultLengthLog2;
// Create and initially fill array for transofmed numbers storing
uint[] resultArray = ArrayPool <uint> .Instance.GetArray(resultLength);
Array.Copy(digits, resultArray, length);
// Create and initially fill array with lengths
uint[] resultArray2 = ArrayPool <uint> .Instance.GetArray(resultLength);
resultArray2[0] = length;
IMultiplier multiplier = MultiplyManager.GetCurrentMultiplier();
IDivider divider = DivideManager.GetCurrentDivider();
// Generate all needed pows of numberBase in stack
Stack baseIntStack = new Stack(resultLengthLog2);
IntX baseInt = null;
for (int i = 0; i < resultLengthLog2; ++i)
{
baseInt = baseInt == null ? numberBase : multiplier.Multiply(baseInt, baseInt);
baseIntStack.Push(baseInt);
}
// Create temporary buffer for second digits when doing div operation
uint[] tempBuffer = new uint[baseInt._length];
// We will use unsafe code here
fixed(uint *resultPtr1Const = resultArray, resultPtr2Const = resultArray2, tempBufferPtr = tempBuffer)
{
// Results pointers which will be modified (on swap)
uint *resultPtr1 = resultPtr1Const;
uint *resultPtr2 = resultPtr2Const;
// Temporary variables used on swapping
uint[] tempArray;
uint * tempPtr;
// Variables used in cycle
uint *ptr1, ptr2, ptr1end;
uint loLength;
// Outer cycle instead of recursion
for (uint innerStep = resultLength >> 1, outerStep = resultLength; innerStep > 0; innerStep >>= 1, outerStep >>= 1)
{
// Prepare pointers
ptr1 = resultPtr1;
ptr2 = resultPtr2;
ptr1end = resultPtr1 + resultLength;
// Get baseInt from stack and fix it too
baseInt = (IntX)baseIntStack.Pop();
fixed(uint *baseIntPtr = baseInt._digits)
{
// Cycle thru all digits and their lengths
for (; ptr1 < ptr1end; ptr1 += outerStep, ptr2 += outerStep)
{
// Divide ptr1 (with length in *ptr2) by baseIntPtr here.
// Results are stored in ptr2 & (ptr2 + innerStep), lengths - in *ptr1 and (*ptr1 + innerStep)
loLength = *ptr2;
*(ptr1 + innerStep) = divider.DivMod(
ptr1,
ptr2,
ref loLength,
baseIntPtr,
tempBufferPtr,
baseInt._length,
ptr2 + innerStep,
DivModResultFlags.Div | DivModResultFlags.Mod,
-2);
*ptr1 = loLength;
}
}
// After inner cycle resultArray will contain lengths and resultArray2 will contain actual values
// so we need to swap them here
tempArray = resultArray;
resultArray = resultArray2;
resultArray2 = tempArray;
tempPtr = resultPtr1;
resultPtr1 = resultPtr2;
resultPtr2 = tempPtr;
}
// Retrieve real output length
outputLength = DigitHelper.GetRealDigitsLength(resultArray2, outputLength);
// Create output array
outputArray = new uint[outputLength];
// Copy each digit but only if length is not null
fixed(uint *outputPtr = outputArray)
{
for (uint i = 0; i < outputLength; ++i)
{
if (resultPtr2[i] != 0)
{
outputPtr[i] = resultPtr1[i];
}
}
}
}
// Return temporary arrays to pool
ArrayPool <uint> .Instance.AddArray(resultArray);
ArrayPool <uint> .Instance.AddArray(resultArray2);
return(outputArray);
}
/// <summary>
/// Creates a new observable property access proxy
/// </summary>
/// <param name="modelElement">The model instance element for which to create the property access proxy</param>
public ValProxy(IMultiplier modelElement) :
base(modelElement, "val")
{
}
IMultiplier _classicMultiplier; // multiplier to use if FHT is unapplicatible
#endregion Private fields
#region Constructor
/// <summary>
/// Creates new <see cref="AutoFhtMultiplier" /> instance.
/// </summary>
/// <param name="classicMultiplier">Multiplier to use if FHT is unapplicatible.</param>
public AutoFhtMultiplier(IMultiplier classicMultiplier)
{
_classicMultiplier = classicMultiplier;
}
IMultiplier _classicMultiplier; // multiplier to use if FHT is unapplicatible
#endregion Private fields
#region Constructor
/// <summary>
/// Creates new <see cref="AutoFhtMultiplier" /> instance.
/// </summary>
/// <param name="classicMultiplier">Multiplier to use if FHT is unapplicatible.</param>
public AutoFhtMultiplier(IMultiplier classicMultiplier)
{
_classicMultiplier = classicMultiplier;
}
public CachedMultiplier(IMultiplier multiplier)
{
_multiplier = multiplier;
}
public SampleMathUtility(IMultiplier multiplier)
{
this.Multiplier = multiplier;
}
/// <summary>
/// Generates integer opposite to the given one using approximation.
/// Uses algorithm from Khuth vol. 2 3rd Edition (4.3.3).
/// </summary>
/// <param name="digitsPtr">Initial big integer digits.</param>
/// <param name="length">Initial big integer length.</param>
/// <param name="maxLength">Precision length.</param>
/// <param name="bufferPtr">Buffer in which shifted big integer may be stored.</param>
/// <param name="newLength">Resulting big integer length.</param>
/// <param name="rightShift">How much resulting big integer is shifted to the left (or: must be shifted to the right).</param>
/// <returns>Resulting big integer digits.</returns>
static unsafe public uint[] GetIntegerOpposite(
uint *digitsPtr,
uint length,
uint maxLength,
uint *bufferPtr,
out uint newLength,
out ulong rightShift)
{
// Maybe initially shift original digits a bit to the left
// (it must have MSB on 2nd position in the highest digit)
int msb = Bits.Msb(digitsPtr[length - 1]);
rightShift = (ulong)(length - 1) * Constants.DigitBitCount + (ulong)msb + 1U;
if (msb != 2)
{
// Shift to the left (via actually right shift)
int leftShift = (2 - msb + Constants.DigitBitCount) % Constants.DigitBitCount;
length = DigitOpHelper.Shr(digitsPtr, length, bufferPtr + 1, Constants.DigitBitCount - leftShift, true) + 1U;
}
else
{
// Simply use the same digits without any shifting
bufferPtr = digitsPtr;
}
// Calculate possible result length
int lengthLog2 = Bits.CeilLog2(maxLength);
uint newLengthMax = 1U << (lengthLog2 + 1);
int lengthLog2Bits = lengthLog2 + Bits.Msb(Constants.DigitBitCount);
// Create result digits
uint[] resultDigits = ArrayPool <uint> .Instance.GetArray(newLengthMax); //new uint[newLengthMax];
uint resultLength;
// Create temporary digits for squared result (twice more size)
uint[] resultDigitsSqr = ArrayPool <uint> .Instance.GetArray(newLengthMax); //new uint[newLengthMax];
uint resultLengthSqr;
// Create temporary digits for squared result * buffer
uint[] resultDigitsSqrBuf = new uint[newLengthMax + length];
uint resultLengthSqrBuf;
// We will always use current multiplier
IMultiplier multiplier = MultiplyManager.GetCurrentMultiplier();
// Fix some digits
fixed(uint *resultPtrFixed = resultDigits, resultSqrPtrFixed = resultDigitsSqr, resultSqrBufPtr = resultDigitsSqrBuf)
{
uint *resultPtr = resultPtrFixed;
uint *resultSqrPtr = resultSqrPtrFixed;
// Cache two first digits
uint bufferDigitN1 = bufferPtr[length - 1];
uint bufferDigitN2 = bufferPtr[length - 2];
// Prepare result.
// Initially result = floor(32 / (4*v1 + 2*v2 + v3)) / 4
// (last division is not floored - here we emulate fixed point)
resultDigits[0] = 32 / bufferDigitN1;
resultLength = 1;
// Prepare variables
uint nextBufferTempStorage = 0;
int nextBufferTempShift;
uint nextBufferLength = 1U;
uint *nextBufferPtr = &nextBufferTempStorage;
ulong bitsAfterDotResult;
ulong bitsAfterDotResultSqr;
ulong bitsAfterDotNextBuffer;
ulong bitShift;
uint shiftOffset;
uint *tempPtr;
uint[] tempDigits;
// Iterate 'till result will be precise enough
for (int k = 0; k < lengthLog2Bits; ++k)
{
// Get result squared
resultLengthSqr = multiplier.Multiply(
resultPtr,
resultLength,
resultPtr,
resultLength,
resultSqrPtr);
// Calculate current result bits after dot
bitsAfterDotResult = (1UL << k) + 1UL;
bitsAfterDotResultSqr = bitsAfterDotResult << 1;
// Here we will get the next portion of data from bufferPtr
if (k < 4)
{
// For now buffer intermediate has length 1 and we will use this fact
nextBufferTempShift = 1 << (k + 1);
nextBufferTempStorage =
bufferDigitN1 << nextBufferTempShift |
bufferDigitN2 >> (Constants.DigitBitCount - nextBufferTempShift);
// Calculate amount of bits after dot (simple formula here)
bitsAfterDotNextBuffer = (ulong)nextBufferTempShift + 3UL;
}
else
{
// Determine length to get from bufferPtr
nextBufferLength = System.Math.Min((1U << (k - 4)) + 1U, length);
nextBufferPtr = bufferPtr + (length - nextBufferLength);
// Calculate amount of bits after dot (simple formula here)
bitsAfterDotNextBuffer = (ulong)(nextBufferLength - 1U) * Constants.DigitBitCount + 3UL;
}
// Multiply result ^ 2 and nextBuffer + calculate new amount of bits after dot
resultLengthSqrBuf = multiplier.Multiply(
resultSqrPtr,
resultLengthSqr,
nextBufferPtr,
nextBufferLength,
resultSqrBufPtr);
bitsAfterDotNextBuffer += bitsAfterDotResultSqr;
// Now calculate 2 * result - resultSqrBufPtr
--bitsAfterDotResult;
--bitsAfterDotResultSqr;
// Shift result on a needed amount of bits to the left
bitShift = bitsAfterDotResultSqr - bitsAfterDotResult;
shiftOffset = (uint)(bitShift / Constants.DigitBitCount);
resultLength =
shiftOffset + 1U +
DigitOpHelper.Shr(
resultPtr,
resultLength,
resultSqrPtr + shiftOffset + 1U,
Constants.DigitBitCount - (int)(bitShift % Constants.DigitBitCount),
true);
// Swap resultPtr and resultSqrPtr pointers
tempPtr = resultPtr;
resultPtr = resultSqrPtr;
resultSqrPtr = tempPtr;
tempDigits = resultDigits;
resultDigits = resultDigitsSqr;
resultDigitsSqr = tempDigits;
DigitHelper.SetBlockDigits(resultPtr, shiftOffset, 0U);
bitShift = bitsAfterDotNextBuffer - bitsAfterDotResultSqr;
shiftOffset = (uint)(bitShift / Constants.DigitBitCount);
if (shiftOffset < resultLengthSqrBuf)
{
// Shift resultSqrBufPtr on a needed amount of bits to the right
resultLengthSqrBuf = DigitOpHelper.Shr(
resultSqrBufPtr + shiftOffset,
resultLengthSqrBuf - shiftOffset,
resultSqrBufPtr,
(int)(bitShift % Constants.DigitBitCount),
false);
// Now perform actual subtraction
resultLength = DigitOpHelper.Sub(
resultPtr,
resultLength,
resultSqrBufPtr,
resultLengthSqrBuf,
resultPtr);
}
else
{
// Actually we can assume resultSqrBufPtr == 0 here and have nothing to do
}
}
}
// Return some arrays to pool
ArrayPool <uint> .Instance.AddArray(resultDigitsSqr);
rightShift += (1UL << lengthLog2Bits) + 1UL;
newLength = resultLength;
return(resultDigits);
}
/// <summary>
/// Parses provided string representation of <see cref="IntX" /> object.
/// </summary>
/// <param name="value">Number as string.</param>
/// <param name="startIndex">Index inside string from which to start.</param>
/// <param name="endIndex">Index inside string on which to end.</param>
/// <param name="numberBase">Number base.</param>
/// <param name="charToDigits">Char->digit dictionary.</param>
/// <param name="digitsRes">Resulting digits.</param>
/// <returns>Parsed integer length.</returns>
override unsafe public uint Parse(string value, int startIndex, int endIndex, uint numberBase, IDictionary <char, uint> charToDigits, uint[] digitsRes)
{
uint newLength = base.Parse(value, startIndex, endIndex, numberBase, charToDigits, digitsRes);
// Maybe base method already parsed this number
if (newLength != 0)
{
return(newLength);
}
// Check length - maybe use classic parser instead
uint initialLength = (uint)digitsRes.LongLength;
if (initialLength < Constants.FastParseLengthLowerBound || initialLength > Constants.FastParseLengthUpperBound)
{
return(_classicParser.Parse(value, startIndex, endIndex, numberBase, charToDigits, digitsRes));
}
uint valueLength = (uint)(endIndex - startIndex + 1);
uint digitsLength = 1U << Bits.CeilLog2(valueLength);
// Prepare array for digits in other base
uint[] valueDigits = ArrayPool <uint> .Instance.GetArray(digitsLength);
// This second array will store integer lengths initially
uint[] valueDigits2 = ArrayPool <uint> .Instance.GetArray(digitsLength);
fixed(uint *valueDigitsStartPtr = valueDigits, valueDigitsStartPtr2 = valueDigits2)
{
// In the string first digit means last in digits array
uint *valueDigitsPtr = valueDigitsStartPtr + valueLength - 1;
uint *valueDigitsPtr2 = valueDigitsStartPtr2 + valueLength - 1;
// Reverse copy characters into digits
fixed(char *valueStartPtr = value)
{
char *valuePtr = valueStartPtr + startIndex;
char *valueEndPtr = valuePtr + valueLength;
for (; valuePtr < valueEndPtr; ++valuePtr, --valueDigitsPtr, --valueDigitsPtr2)
{
// Get digit itself - this call will throw an exception if char is invalid
*valueDigitsPtr = StrRepHelper.GetDigit(charToDigits, *valuePtr, numberBase);
// Set length of this digit (zero for zero)
*valueDigitsPtr2 = *valueDigitsPtr == 0U ? 0U : 1U;
}
}
// We have retrieved lengths array from pool - it needs to be cleared before using
DigitHelper.SetBlockDigits(valueDigitsStartPtr2 + valueLength, digitsLength - valueLength, 0);
// Now start from the digit arrays beginning
valueDigitsPtr = valueDigitsStartPtr;
valueDigitsPtr2 = valueDigitsStartPtr2;
// Current multiplier (classic or fast) will be used
IMultiplier multiplier = MultiplyManager.GetCurrentMultiplier();
// Here base in needed power will be stored
IntX baseInt = null;
// Temporary variables used on swapping
uint[] tempDigits;
uint * tempPtr;
// Variables used in cycle
uint *ptr1, ptr2, valueDigitsPtrEnd;
uint loLength, hiLength;
// Outer cycle instead of recursion
for (uint innerStep = 1, outerStep = 2; innerStep < digitsLength; innerStep <<= 1, outerStep <<= 1)
{
// Maybe baseInt must be multiplied by itself
baseInt = baseInt == null ? numberBase : baseInt * baseInt;
// Using unsafe here
fixed(uint *baseDigitsPtr = baseInt._digits)
{
// Start from arrays beginning
ptr1 = valueDigitsPtr;
ptr2 = valueDigitsPtr2;
// vauleDigits array end
valueDigitsPtrEnd = valueDigitsPtr + digitsLength;
// Cycle thru all digits and their lengths
for (; ptr1 < valueDigitsPtrEnd; ptr1 += outerStep, ptr2 += outerStep)
{
// Get lengths of "lower" and "higher" value parts
loLength = *ptr2;
hiLength = *(ptr2 + innerStep);
if (hiLength != 0)
{
// We always must clear an array before multiply
DigitHelper.SetBlockDigits(ptr2, outerStep, 0U);
// Multiply per baseInt
hiLength = multiplier.Multiply(
baseDigitsPtr,
baseInt._length,
ptr1 + innerStep,
hiLength,
ptr2);
}
// Sum results
if (hiLength != 0 || loLength != 0)
{
*ptr1 = DigitOpHelper.Add(
ptr2,
hiLength,
ptr1,
loLength,
ptr2);
}
else
{
*ptr1 = 0U;
}
}
}
// After inner cycle valueDigits will contain lengths and valueDigits2 will contain actual values
// so we need to swap them here
tempDigits = valueDigits;
valueDigits = valueDigits2;
valueDigits2 = tempDigits;
tempPtr = valueDigitsPtr;
valueDigitsPtr = valueDigitsPtr2;
valueDigitsPtr2 = tempPtr;
}
}
// Determine real length of converted number
uint realLength = valueDigits2[0];
// Copy to result
Array.Copy(valueDigits, digitsRes, realLength);
// Return arrays to pool
ArrayPool <uint> .Instance.AddArray(valueDigits);
ArrayPool <uint> .Instance.AddArray(valueDigits2);
return(realLength);
}
/// <summary>
/// Divides two big integers.
/// Also modifies <paramref name="digitsPtr1" /> and <paramref name="length1"/> (it will contain remainder).
/// </summary>
/// <param name="digitsPtr1">First big integer digits.</param>
/// <param name="digitsBufferPtr1">Buffer for first big integer digits. May also contain remainder.</param>
/// <param name="length1">First big integer length.</param>
/// <param name="digitsPtr2">Second big integer digits.</param>
/// <param name="digitsBufferPtr2">Buffer for second big integer digits. Only temporarily used.</param>
/// <param name="length2">Second big integer length.</param>
/// <param name="digitsResPtr">Resulting big integer digits.</param>
/// <param name="resultFlags">Which operation results to return.</param>
/// <param name="cmpResult">Big integers comparsion result (pass -2 if omitted).</param>
/// <returns>Resulting big integer length.</returns>
override unsafe public uint DivMod(
uint *digitsPtr1,
uint *digitsBufferPtr1,
ref uint length1,
uint *digitsPtr2,
uint *digitsBufferPtr2,
uint length2,
uint *digitsResPtr,
DivModResultFlags resultFlags,
int cmpResult)
{
// Maybe immediately use classic algorithm here
if (IsClassicAlgorithmNeeded(length1, length2))
{
return(_classicDivider.DivMod(
digitsPtr1,
digitsBufferPtr1,
ref length1,
digitsPtr2,
digitsBufferPtr2,
length2,
digitsResPtr,
resultFlags,
cmpResult));
}
// Call base (for special cases)
uint resultLength = base.DivMod(
digitsPtr1,
digitsBufferPtr1,
ref length1,
digitsPtr2,
digitsBufferPtr2,
length2,
digitsResPtr,
resultFlags,
cmpResult);
if (resultLength != uint.MaxValue)
{
return(resultLength);
}
// First retrieve opposite for the divider
uint int2OppositeLength;
ulong int2OppositeRightShift;
uint[] int2OppositeDigits = NewtonHelper.GetIntegerOpposite(
digitsPtr2,
length2,
length1,
digitsBufferPtr1,
out int2OppositeLength,
out int2OppositeRightShift);
// We will need to muptiply it by divident now to receive quotient.
// Prepare digits for multiply result
uint quotLength;
uint[] quotDigits = new uint[length1 + int2OppositeLength];
IMultiplier multiplier = MultiplyManager.GetCurrentMultiplier();
// Fix some arrays
fixed(uint *oppositePtr = int2OppositeDigits, quotPtr = quotDigits)
{
// Multiply
quotLength = multiplier.Multiply(
oppositePtr,
int2OppositeLength,
digitsPtr1,
length1,
quotPtr);
// Calculate shift
uint shiftOffset = (uint)(int2OppositeRightShift / Constants.DigitBitCount);
int shiftCount = (int)(int2OppositeRightShift % Constants.DigitBitCount);
// Get the very first bit of the shifted part
uint highestLostBit;
if (shiftCount == 0)
{
highestLostBit = quotPtr[shiftOffset - 1] >> 31;
}
else
{
highestLostBit = quotPtr[shiftOffset] >> (shiftCount - 1) & 1U;
}
// After this result must be shifted to the right - this is required
quotLength = DigitOpHelper.Shr(
quotPtr + shiftOffset,
quotLength - shiftOffset,
quotPtr,
shiftCount,
false);
// Maybe quotient must be corrected
if (highestLostBit == 1U)
{
quotLength = DigitOpHelper.Add(quotPtr, quotLength, &highestLostBit, 1U, quotPtr);
}
// Check quotient - finally it might be too big.
// For this we must multiply quotient by divider
uint quotDivLength;
uint[] quotDivDigits = new uint[quotLength + length2];
fixed(uint *quotDivPtr = quotDivDigits)
{
quotDivLength = multiplier.Multiply(quotPtr, quotLength, digitsPtr2, length2, quotDivPtr);
int cmpRes = DigitOpHelper.Cmp(quotDivPtr, quotDivLength, digitsPtr1, length1);
if (cmpRes > 0)
{
highestLostBit = 1;
quotLength = DigitOpHelper.Sub(quotPtr, quotLength, &highestLostBit, 1U, quotPtr);
quotDivLength = DigitOpHelper.Sub(quotDivPtr, quotDivLength, digitsPtr2, length2, quotDivPtr);
}
// Now everything is ready and prepared to return results
// First maybe fill remainder
if ((resultFlags & DivModResultFlags.Mod) != 0)
{
length1 = DigitOpHelper.Sub(digitsPtr1, length1, quotDivPtr, quotDivLength, digitsBufferPtr1);
}
// And finally fill quotient
if ((resultFlags & DivModResultFlags.Div) != 0)
{
DigitHelper.DigitsBlockCopy(quotPtr, digitsResPtr, quotLength);
}
else
{
quotLength = 0;
}
// Return some arrays to pool
ArrayPool <uint> .Instance.AddArray(int2OppositeDigits);
return(quotLength);
}
}
}
private List <TestMethodInstance> GetMethodInstance(IEnumerable <object[]> param, List <TestMethodInstance> result, object classInstance, IMultiplier methodMultiplier)
{
foreach (var parametersValue in param)
{
// TODO : move everything to a multiplier construct, ie InvocationCount * whatever else. ?
// for each invoc count
for (var i = 0; i < Attribute.InvocationCount; i++)
{
// multiply the tests if needed, for instance if multiple browers are needed
var res = methodMultiplier.Multiply(Method);
if (res.Count == 0)
{
var metadata = new Dictionary <string, object>();
result.Add(new TestMethodInstance(Attribute, metadata, parametersValue, classInstance, Method));
}
else
{
foreach (var o in res)
{
var metadata = new Dictionary <string, object>();
metadata[methodMultiplier.Key()] = o;
result.Add(new TestMethodInstance(Attribute, metadata, parametersValue, classInstance, Method));
}
}
}
}
return(result);
}
