/// <summary>
/// Instancia um objecto do tipo <see cref="SquareRoot{ObjectType}"/>.
/// </summary>
/// <param name="integerPart">A parte inteira da raiz qaudrada.</param>
/// <param name="rootNumberFactorization">A facotorização do número inteiro.</param>
/// <param name="multipliable">O objecto responsável pela multiplicação dos números.</param>
public SquareRoot(
ObjectType integerPart,
Dictionary <ObjectType, int> rootNumberFactorization,
IMultiplication <ObjectType> multipliable)
{
this.SetupParameters(integerPart, rootNumberFactorization, multipliable);
this.ComputeRootNumber(multipliable);
}
public override void Visit(IMultiplication multiplication)
{
if (Process(multiplication))
{
visitor.Visit(multiplication);
}
base.Visit(multiplication);
}
private HLLocation ProcessMultiplicationExpression(IMultiplication pExpression)
{
HLLocation locationLeftOperand = ProcessExpression(pExpression.LeftOperand);
HLLocation locationRightOperand = ProcessExpression(pExpression.RightOperand);
HLLocation locationTemporary = HLTemporaryLocation.Create(CreateTemporary(HLDomain.GetOrCreateType(pExpression.Type)));
mCurrentBlock.EmitMultiply(locationTemporary, locationLeftOperand, locationRightOperand);
return(pExpression.ResultIsUnmodifiedLeftOperand ? locationLeftOperand : locationTemporary);
}
/// <summary>
/// Determina o valor do radicando após o processamento.
/// </summary>
/// <param name="multipliable">O objecto responsável pelas multiplicações.</param>
private void ComputeRootNumber(IMultiplication <ObjectType> multipliable)
{
this.rootNumber = multipliable.MultiplicativeUnity;
foreach (var factKvp in rootNumberFactorization)
{
this.rootNumber = multipliable.Multiply(
this.rootNumber,
factKvp.Key);
}
}
/// <summary>
/// Instancia um objecto do tipo <see cref="SquareRoot{ObjectType}"/>.
/// </summary>
/// <param name="integerPart">A parte inteira da raiz qaudrada.</param>
/// <param name="rootNumber">The root number.</param>
/// <param name="factorizationAlg">O algoritmo responsável pela factorização.</param>
/// <param name="multipliable">O objecto responsável pela multiplicação dos números.</param>
/// <param name="comparer">O comparador de números.</param>
public SquareRoot(
ObjectType integerPart,
ObjectType rootNumber,
IAlgorithm <ObjectType, Tuple <ObjectType, ObjectType> > factorizationAlg,
IMultiplication <ObjectType> multipliable,
IEqualityComparer <ObjectType> comparer)
{
this.SetupParameters(
integerPart,
rootNumber,
factorizationAlg,
multipliable,
comparer);
this.ComputeRootNumber(multipliable);
}
/// <summary>
/// Obtém o produto da raiz actual com outra raiz.
/// </summary>
/// <param name="right">A outra raiz.</param>
/// <param name="multipliable">O objecto responsável pelas multiplicações.</param>
/// <returns>O resultado do produto.</returns>
/// <exception cref="ArgumentNullException">Se algum dos argumentos for nulo.</exception>
public SquareRoot <ObjectType> Multiply(
SquareRoot <ObjectType> right,
IMultiplication <ObjectType> multipliable)
{
if (right == null)
{
throw new ArgumentNullException("right");
}
else if (multipliable == null)
{
throw new ArgumentNullException("multipliable");
}
else
{
var result = new SquareRoot <ObjectType>();
result.integerPart = multipliable.Multiply(this.integerPart, right.integerPart);
result.rootNumberFactorization = new Dictionary <ObjectType, int>(
this.rootNumberFactorization.Comparer);
var temporaryFactorization = new Dictionary <ObjectType, int>(this.rootNumberFactorization.Comparer);
foreach (var kvp in right.rootNumberFactorization)
{
temporaryFactorization.Add(kvp.Key, kvp.Value);
}
foreach (var kvp in this.rootNumberFactorization)
{
if (temporaryFactorization.ContainsKey(kvp.Key))
{
result.integerPart = multipliable.Multiply(result.integerPart, kvp.Key);
temporaryFactorization.Remove(kvp.Key);
}
else
{
result.rootNumberFactorization.Add(kvp.Key, 1);
}
}
foreach (var kvp in temporaryFactorization)
{
result.rootNumberFactorization.Add(kvp.Key, kvp.Value);
}
this.ComputeRootNumber(multipliable);
return(result);
}
}
/// <summary>
/// Instancia um objecto do tipo <see cref="SquareRoot{ObjectType}"/>.
/// </summary>
/// <param name="integerPart">A parte inteira da raiz qaudrada.</param>
/// <param name="rootNumber">O número na raiz.</param>
/// <param name="factorizationAlg">O algoritmo responsável pela factorização.</param>
/// <param name="multipliable">O objecto responsável pela multiplicação dos números.</param>
/// <exception cref="ArgumentNullException">Se o algorimo da factorização for nulo.</exception>
public SquareRoot(
ObjectType integerPart,
ObjectType rootNumber,
IAlgorithm <ObjectType, Dictionary <ObjectType, int> > factorizationAlg,
IMultiplication <ObjectType> multipliable)
{
if (factorizationAlg == null)
{
throw new ArgumentNullException("factorizationAlg");
}
else
{
var factorization = factorizationAlg.Run(rootNumber);
this.SetupParameters(integerPart, factorization, multipliable);
this.ComputeRootNumber(multipliable);
}
}
/// <summary>
/// Cria um nova instância de um objecto do tipo <see cref="FractionComparer{CoeffType}"/>.
/// </summary>
/// <param name="comparer">O comparador de coeficientes das fracções.</param>
/// <param name="multipliable">
/// O objecto responsável pelas operações de multiplicação dos coeficientes
/// da fracções.
/// </param>
/// <exception cref="ArgumentNullException">
/// Caso o objecto responsável pelas multiplicações seja nulo.
/// </exception>
public FractionComparer(IComparer <CoeffType> comparer, IMultiplication <CoeffType> multipliable)
{
if (multipliable == null)
{
throw new ArgumentNullException("multipliable");
}
else
{
if (comparer == null)
{
this.comparer = Comparer <CoeffType> .Default;
}
else
{
this.comparer = comparer;
}
this.multipliable = multipliable;
}
}
/// <summary>
/// Establece os parâmetros internos com base nos argumentos externos.
/// </summary>
/// <param name="integerPart">A parte inteira da raiz.</param>
/// <param name="rootNumberFactorization">A factorização do radicando.</param>
/// <param name="multipliable">O objecto responsável pela multiplicação de coeficientes.</param>
/// <exception cref="ArgumentNullException">Se algum dos argumentos for nulo.</exception>
private void SetupParameters(
ObjectType integerPart,
Dictionary <ObjectType, int> rootNumberFactorization,
IMultiplication <ObjectType> multipliable)
{
if (integerPart == null)
{
throw new ArgumentNullException("integerPart");
}
else if (rootNumberFactorization == null)
{
throw new ArgumentNullException("rootNumberFactorization");
}
else if (multipliable == null)
{
throw new ArgumentNullException("multipliable");
}
else
{
this.integerPart = integerPart;
this.rootNumberFactorization = new Dictionary <ObjectType, int>(rootNumberFactorization.Comparer);
foreach (var fact in rootNumberFactorization)
{
var factDegree = fact.Value;
var factSquaredValue = factDegree / 2;
var factRem = factDegree % 2;
this.integerPart = multipliable.Multiply(
this.integerPart,
MathFunctions.Power(fact.Key, factSquaredValue, multipliable));
if (factRem == 1)
{
rootNumberFactorization.Add(fact.Key, 1);
}
}
}
}
/// <summary>
/// Determina o produto de duas matrizes multidimensionais.
/// </summary>
/// <param name="right">A matriz multidimensional a ser somada.</param>
/// <param name="multiplyable">O objeto responsável pelas operações sobre os coeficientes.</param>
/// <returns>O resultado do produto.</returns>
/// <exception cref="ArgumentNullException">Se um dos argumentos for nulo.</exception>
public MultiDimensionalMathRange <T> Multiply(MultiDimensionalMathRange <T> right, IMultiplication <T> multiplyable)
{
if (right == null)
{
throw new ArgumentNullException("right");
}
if (multiplyable == null)
{
throw new ArgumentNullException("A multiplyable structure is needed.");
}
var result = new MultiDimensionalMathRange <T>();
if (this.configuration.Length == 0 || right.configuration.Length == 0)
{
result.configuration = new int[0];
result.elements = new T[0];
}
else
{
var p = 1;
var q = 1;
for (int i = 0; i < this.configuration.Length; ++i)
{
p *= this.configuration[i];
}
for (int i = 0; i < right.configuration[i]; ++i)
{
q *= right.configuration[i];
}
result.elements = new T[p * q];
result.configuration = new int[this.configuration.Length + right.configuration.Length];
for (int i = 0; i < this.configuration.Length; ++i)
{
result.configuration[i] = this.configuration[i];
}
for (int i = 0; i < right.configuration.Length; ++i)
{
result.configuration[this.configuration.Length + i] = right.configuration[i];
}
for (int i = 0; i < p; ++i)
{
for (int j = 0; j < q; ++j)
{
result.elements[j * p + i] = multiplyable.Multiply(this.elements[i], right.elements[j]);
}
}
}
return(result);
}
/// <summary>
/// Performs some computation with the given multiplication expression.
/// </summary>
/// <param name="multiplication"></param>
public virtual void Visit(IMultiplication multiplication)
{
this.Visit((IBinaryOperation)multiplication);
}
public void Visit(IMultiplication multiplication)
{
throw new NotImplementedException();
}
/// <summary>
/// Performs some computation with the given multiplication expression.
/// </summary>
/// <param name="multiplication"></param>
public virtual void Visit(IMultiplication multiplication)
{
}
/// <summary>
/// Traverses the children of the multiplication expression.
/// </summary>
public virtual void TraverseChildren(IMultiplication multiplication)
{
Contract.Requires(multiplication != null);
this.TraverseChildren((IBinaryOperation)multiplication);
}
/// <summary>
/// Returns a shallow copy of the given multiplication expression.
/// </summary>
/// <param name="multiplication"></param>
public Multiplication Copy(IMultiplication multiplication)
{
return new Multiplication(multiplication);
}
/// <summary>
///
/// </summary>
/// <param name="multiplication"></param>
public Multiplication(IMultiplication multiplication)
: base(multiplication) {
this.CheckOverflow = multiplication.CheckOverflow;
this.TreatOperandsAsUnsignedIntegers = multiplication.TreatOperandsAsUnsignedIntegers;
}
/// <summary>
/// Generates IL for the specified multiplication.
/// </summary>
/// <param name="multiplication">The multiplication.</param>
public override void TraverseChildren(IMultiplication multiplication)
{
this.Traverse(multiplication.LeftOperand);
this.Traverse(multiplication.RightOperand);
OperationCode operationCode = OperationCode.Mul;
if (multiplication.CheckOverflow) {
if (multiplication.TreatOperandsAsUnsignedIntegers)
operationCode = OperationCode.Mul_Ovf_Un;
else
operationCode = OperationCode.Mul_Ovf;
}
this.generator.Emit(operationCode);
this.StackSize--;
}
public override void TraverseChildren(IMultiplication multiplication)
{
var targetExpression = multiplication.LeftOperand as ITargetExpression;
if (targetExpression != null) { // x *= e
bool statement = this.currentExpressionIsOpAssignStatement;
this.currentExpressionIsOpAssignStatement = false;
this.VisitAssignment(targetExpression, multiplication, (IExpression e) => this.TraverseMultiplicationRightOperandAndDoOperation(e),
treatAsStatement: statement, pushTargetRValue: true, resultIsInitialTargetRValue: multiplication.ResultIsUnmodifiedLeftOperand);
} else { // x * e
this.Traverse(multiplication.LeftOperand);
this.TraverseMultiplicationRightOperandAndDoOperation(multiplication);
}
}
/// <summary>
/// Returns a shallow copy of the given multiplication expression.
/// </summary>
/// <param name="multiplication"></param>
public Multiplication Copy(IMultiplication multiplication) {
Contract.Requires(multiplication != null);
Contract.Ensures(Contract.Result<Multiplication>() != null);
return new Multiplication(multiplication);
}
/// <summary>
/// Returns a deep copy of the given multiplication expression.
/// </summary>
/// <param name="multiplication"></param>
public Multiplication Copy(IMultiplication multiplication) {
Contract.Requires(multiplication != null);
Contract.Ensures(Contract.Result<Multiplication>() != null);
var mutableCopy = this.shallowCopier.Copy(multiplication);
this.CopyChildren((BinaryOperation)mutableCopy);
return mutableCopy;
}
public override void TraverseChildren(IMultiplication multiplication) {
base.TraverseChildren(multiplication);
((Multiplication)multiplication).Type = this.GetBinaryNumericOperationType(multiplication, multiplication.TreatOperandsAsUnsignedIntegers);
}
/// <summary>
/// Rewrites the given multiplication expression.
/// </summary>
/// <param name="multiplication"></param>
public virtual IExpression Rewrite(IMultiplication multiplication)
{
return multiplication;
}
public override void Visit(IMultiplication multiplication)
{
allElements.Add(new InvokInfo(Traverser, "IMultiplication", multiplication));
}
public override void Visit(IMultiplication multiplication)
{
if(Process(multiplication)){visitor.Visit(multiplication);}
base.Visit(multiplication);
}
public override IExpression Rewrite(IMultiplication operation)
{
return(ReplaceOperation(operation));
}
/// <summary>
/// Returns a deep copy of the given multiplication expression.
/// </summary>
/// <param name="multiplication"></param>
public Multiplication Copy(IMultiplication multiplication)
{
var mutableCopy = this.shallowCopier.Copy(multiplication);
this.CopyChildren((BinaryOperation)mutableCopy);
return mutableCopy;
}
public override void TraverseChildren(IMultiplication multiplication)
{ MethodEnter(multiplication);
base.TraverseChildren(multiplication);
MethodExit(); }
public void Visit(IMultiplication multiplication)
{
this.result = this.copier.Copy(multiplication);
}
public override void TraverseChildren(IMultiplication multiplication)
{
base.TraverseChildren(multiplication);
((Multiplication)multiplication).Type = this.GetBinaryNumericOperationType(multiplication, multiplication.TreatOperandsAsUnsignedIntegers);
}
public virtual void onASTElement(IMultiplication multiplication)
{
}
/// <summary>
/// Establece os parâmetros internos com base nos argumentos externos.
/// </summary>
/// <param name="integerPart">A parte inteira da raiz qaudrada.</param>
/// <param name="rootNumber">The root number.</param>
/// <param name="factorizationAlg">O algoritmo responsável pela factorização.</param>
/// <param name="multipliable">O objecto responsável pela multiplicação dos números.</param>
/// <param name="comparer">O comparador de números.</param>
/// <exception cref="ArgumentNullException">Se algum dos argumentos for nulo.</exception>
private void SetupParameters(
ObjectType integerPart,
ObjectType rootNumber,
IAlgorithm <ObjectType, Tuple <ObjectType, ObjectType> > factorizationAlg,
IMultiplication <ObjectType> multipliable,
IEqualityComparer <ObjectType> comparer)
{
if (integerPart == null)
{
throw new ArgumentNullException("integerPart");
}
else if (rootNumber == null)
{
throw new ArgumentNullException("rootNumber");
}
else if (factorizationAlg == null)
{
throw new ArgumentNullException("factorizationAlg");
}
else if (multipliable == null)
{
throw new ArgumentNullException("multipliable");
}
else if (comparer == null)
{
throw new ArgumentNullException("comparer");
}
else
{
this.integerPart = integerPart;
this.rootNumber = rootNumber;
this.rootNumberFactorization = new Dictionary <ObjectType, int>(
comparer);
var alreadyComputed = new Dictionary <ObjectType, Tuple <ObjectType, ObjectType> >(
comparer
);
var factorsStack = new Stack <ObjectType>();
factorsStack.Push(rootNumber);
while (factorsStack.Count > 0)
{
var top = factorsStack.Pop();
var topFactor = default(Tuple <ObjectType, ObjectType>);
if (!alreadyComputed.TryGetValue(top, out topFactor))
{
topFactor = factorizationAlg.Run(top);
alreadyComputed.Add(top, topFactor);
}
if (multipliable.IsMultiplicativeUnity(topFactor.Item1))
{
var deg = 0;
if (this.rootNumberFactorization.TryGetValue(topFactor.Item2, out deg))
{
this.rootNumberFactorization.Remove(topFactor.Item2);
this.integerPart = multipliable.Multiply(
this.integerPart,
topFactor.Item2);
}
else
{
this.rootNumberFactorization.Add(topFactor.Item2, 1);
}
}
else if (multipliable.IsMultiplicativeUnity(topFactor.Item2))
{
var deg = 0;
if (this.rootNumberFactorization.TryGetValue(topFactor.Item1, out deg))
{
this.rootNumberFactorization.Remove(topFactor.Item1);
this.integerPart = multipliable.Multiply(
this.integerPart,
topFactor.Item1);
}
else
{
this.rootNumberFactorization.Add(topFactor.Item1, 1);
}
}
else
{
factorsStack.Push(topFactor.Item1);
factorsStack.Push(topFactor.Item2);
}
}
}
}
public override void Visit(IMultiplication operation)
{
ProcessOperation(operation);
}
public void Visit(IMultiplication multiplication)
{
this.result = this.rewriter.Rewrite(multiplication);
}
//^ ensures this.path.Count == old(this.path.Count);
/// <summary>
/// Traverses the given multiplication expression.
/// </summary>
/// <param name="multiplication"></param>
public virtual void Visit(IMultiplication multiplication)
{
if (this.stopTraversal) return;
//^ int oldCount = this.path.Count;
this.path.Push(multiplication);
this.Visit(multiplication.LeftOperand);
this.Visit(multiplication.RightOperand);
//^ assume this.path.Count == oldCount+1; //True because all of the virtual methods of this class promise not to decrease this.path.Count.or operation is not implemented.");
this.path.Pop();
}
/// <summary>
/// Rewrites the given multiplication expression.
/// </summary>
/// <param name="multiplication"></param>
public virtual IExpression Rewrite(IMultiplication multiplication)
{
var mutableMultiplication = multiplication as Multiplication;
if (mutableMultiplication == null) return multiplication;
this.RewriteChildren(mutableMultiplication);
return mutableMultiplication;
}
/// <summary>
/// Traverses the multiplication expression.
/// </summary>
public void Traverse(IMultiplication multiplication)
{
Contract.Requires(multiplication != null);
if (this.preorderVisitor != null) this.preorderVisitor.Visit(multiplication);
if (this.StopTraversal) return;
this.TraverseChildren(multiplication);
if (this.StopTraversal) return;
if (this.postorderVisitor != null) this.postorderVisitor.Visit(multiplication);
}
public override void Visit(IMultiplication binary)
{
_formattedValue = Format(binary.LeftOperand) + " * " + Format(binary.RightOperand);
}
public void Visit(IMultiplication multiplication)
{
this.traverser.Traverse(multiplication);
}
public virtual void onASTElement(IMultiplication multiplication) { }
public void Visit(IMultiplication multiplication)
{
Contract.Requires(multiplication != null);
throw new NotImplementedException();
}
/// <summary>
/// Visits the specified multiplication.
/// </summary>
/// <param name="multiplication">The multiplication.</param>
public override void Visit(IMultiplication multiplication)
{
Multiplication mutableMultiplication = multiplication as Multiplication;
if (alwaysMakeACopy || mutableMultiplication == null) mutableMultiplication = new Multiplication(multiplication);
this.resultExpression = this.myCodeMutator.Visit(mutableMultiplication);
}
public override void Visit(IMultiplication multiplication) {
base.Visit(multiplication);
Bpl.Expr rexp = TranslatedExpressions.Pop();
Bpl.Expr lexp = TranslatedExpressions.Pop();
TranslatedExpressions.Push(Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Mul, lexp, rexp));
}
/// <summary>
/// Visits the specified multiplication.
/// </summary>
/// <param name="multiplication">The multiplication.</param>
public override void Visit(IMultiplication multiplication)
{
Multiplication mutableMultiplication = new Multiplication(multiplication);
this.resultExpression = this.myCodeCopier.DeepCopy(mutableMultiplication);
}
/// <summary>
///
/// </summary>
/// <param name="multiplication"></param>
public Multiplication(IMultiplication multiplication)
: base(multiplication)
{
this.CheckOverflow = multiplication.CheckOverflow;
}
private HLLocation ProcessMultiplicationExpression(IMultiplication pExpression)
{
HLLocation locationLeftOperand = ProcessExpression(pExpression.LeftOperand);
HLLocation locationRightOperand = ProcessExpression(pExpression.RightOperand);
HLLocation locationTemporary = HLTemporaryLocation.Create(CreateTemporary(HLDomain.GetOrCreateType(pExpression.Type)));
mCurrentBlock.EmitMultiply(locationTemporary, locationLeftOperand, locationRightOperand);
return pExpression.ResultIsUnmodifiedLeftOperand ? locationLeftOperand : locationTemporary;
}
public override void TraverseChildren(IMultiplication multiplication) {
var needsParen = LowerPrecedenceThanParentExpression(multiplication);
var savedCurrentPrecedence = this.currentPrecedence;
this.currentPrecedence = this.Precedence(multiplication);
if (needsParen) this.sourceEmitterOutput.Write("(");
this.Traverse(multiplication.LeftOperand);
if (multiplication.LeftOperand is ITargetExpression)
this.sourceEmitterOutput.Write(" *= ");
else
this.sourceEmitterOutput.Write(" * ");
this.Traverse(multiplication.RightOperand);
if (needsParen) this.sourceEmitterOutput.Write(")");
this.currentPrecedence = savedCurrentPrecedence;
}
/// <summary>
/// Performs some computation with the given multiplication expression.
/// </summary>
/// <param name="multiplication"></param>
public virtual void Visit(IMultiplication multiplication)
{
}
public override void TraverseChildren(IMultiplication multiplication)
{
MethodEnter(multiplication);
base.TraverseChildren(multiplication);
MethodExit();
}
/// <summary>
/// Visits the specified multiplication.
/// </summary>
/// <param name="multiplication">The multiplication.</param>
public override void Visit(IMultiplication multiplication)
{
Multiplication mutableMultiplication = multiplication as Multiplication;
if (mutableMultiplication == null) {
this.resultExpression = multiplication;
return;
}
this.resultExpression = this.myCodeMutator.Visit(mutableMultiplication);
}
