private ComputationResult EvaluateAddIsMatrix(ComputationResult lhs, ComputationResult rhs, ComputationResult add)
{
if (lhs.IsVectorResult && lhs.Direction == ComputationResult.VectorDirection.Unassigned)
{
return(new ComputationResult("Unable to multiply vector without directionality starting at position " + MulLhs.Start + "!"));
}
if (rhs.IsVectorResult && rhs.Direction == ComputationResult.VectorDirection.Unassigned)
{
return(new ComputationResult("Unable to multiply vector without directionality starting at position " + MulRhs.Start + "!"));
}
// Ensure that the LHS is a higher or equal order to the RHS (Matrix > Vector > Scalar)
if (!lhs.IsOdResult)
{
Swap(ref lhs, ref rhs);
}
if (lhs.IsValue)
{
Swap(ref lhs, ref rhs);
}
// LHS is now a higher or equal to the order of RHS
if (lhs.IsOdResult)
{
if (rhs.IsOdResult)
{
var retMatrix = add.Accumulator ? add.OdData :
(lhs.Accumulator ? lhs.OdData :
(rhs.Accumulator ? rhs.OdData : add.OdData.CreateSimilarArray <float>()));
VectorHelper.FusedMultiplyAdd(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.OdData.GetFlatData(), add.OdData.GetFlatData());
return(new ComputationResult(retMatrix, true));
}
else if (rhs.IsVectorResult)
{
var retMatrix = add.Accumulator ? add.OdData :
(lhs.Accumulator ? lhs.OdData : add.OdData.CreateSimilarArray <float>());
if (rhs.Direction == ComputationResult.VectorDirection.Vertical)
{
VectorHelper.FusedMultiplyAddVerticalRhs(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.VectorData.GetFlatData(), add.OdData.GetFlatData());
}
else
{
VectorHelper.FusedMultiplyAddHorizontalRhs(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.VectorData.GetFlatData(), add.OdData.GetFlatData());
}
return(new ComputationResult(retMatrix, true));
}
else
{
//RHS is scalar
var retMatrix = add.Accumulator ? add.OdData :
(lhs.Accumulator ? lhs.OdData : add.OdData.CreateSimilarArray <float>());
VectorHelper.FusedMultiplyAdd(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.LiteralValue, add.OdData.GetFlatData());
return(new ComputationResult(retMatrix, true));
}
}
else if (lhs.IsVectorResult)
{
var retMatrix = add.Accumulator ? add.OdData : add.OdData.CreateSimilarArray <float>();
var tempVector = lhs.Accumulator ? lhs.VectorData : (rhs.IsVectorResult && rhs.Accumulator ? rhs.VectorData : lhs.VectorData.CreateSimilarArray <float>());
// compute the multiplication separately in this case for better performance (n multiplies instead of n^2)
if (rhs.IsVectorResult)
{
if (lhs.Direction != rhs.Direction)
{
// if the directions don't add up then the sum operation would be undefined!
return(new ComputationResult("Unable to add vector without directionality starting at position " + MulLhs.Start + "!"));
}
VectorHelper.Multiply(tempVector.GetFlatData(), 0, lhs.VectorData.GetFlatData(), 0, rhs.VectorData.GetFlatData(), 0, tempVector.GetFlatData().Length);
}
else
{
VectorHelper.Multiply(tempVector.GetFlatData(), lhs.VectorData.GetFlatData(), rhs.LiteralValue);
}
if (lhs.Direction == ComputationResult.VectorDirection.Vertical)
{
VectorHelper.AddVertical(retMatrix.GetFlatData(), add.OdData.GetFlatData(), tempVector.GetFlatData());
}
else
{
VectorHelper.AddHorizontal(retMatrix.GetFlatData(), add.OdData.GetFlatData(), tempVector.GetFlatData());
}
return(new ComputationResult(retMatrix, true));
}
else
{
// in this case LHS is a scalar, and therefore RHS is also a scalar
var retMatrix = add.Accumulator ? add.OdData : add.OdData.CreateSimilarArray <float>();
VectorHelper.Add(retMatrix.GetFlatData(), add.OdData.GetFlatData(), lhs.LiteralValue * rhs.LiteralValue);
return(new ComputationResult(retMatrix, true));
}
}
