/// <summary>
/// The function receive rows from vectors or matrices or may be tensors
/// </summary>
/// <param name="values">Vectors</param>
/// <returns></returns>
public static QsValue MatrixFromValues(params QsValue[] values)
{
if (values[0] is QsTensor)
{
if (values.Count() == 1)
{
return(values[0]);
}
// treat the case of tensors
QsTensor tensor = new QsTensor();
foreach (var tn in values)
{
if (tn.GetType() != typeof(QsTensor))
{
throw new QsException("Non Tensor in a matrix of tensors is not valid expression.");
}
else
{
tensor.AddInnerTensor((QsTensor)tn);
}
}
return(tensor);
}
QsMatrix mat = new QsMatrix();
foreach (var val in values)
{
if (val is QsVector)
{
mat.AddVector((QsVector)val);
}
else if (val is QsMatrix)
{
foreach (var vc in ((QsMatrix)val))
{
mat.AddVector((QsVector)vc);
}
}
else
{
throw new QsInvalidOperationException("Value to be added is not a vector nor a matrix.");
}
}
return(mat);
}
/// <summary>
///
/// </summary>
/// <param name="values">Matrices or Tensors</param>
/// <returns></returns>
public static QsValue TensorFromValues(params QsValue[] values)
{
QsTensor tens = new QsTensor();
foreach (var val in values)
{
if (val is QsMatrix)
{
tens.AddMatrix((QsMatrix)val);
}
else if (val is QsTensor)
{
tens.AddInnerTensor((QsTensor)val);
}
else
{
throw new QsException("Component is not a matrix value.");
}
}
return(tens);
}
public override QsValue SubtractOperation(QsValue vl)
{
QsValue value;
if (vl is QsReference)
{
value = ((QsReference)vl).ContentValue;
}
else
{
value = vl;
}
if (value is QsScalar)
{
var scalar = value as QsScalar;
QsTensor NewTensor = new QsTensor();
if (this.Order > 3)
{
foreach (var iTensor in this.InnerTensors)
{
NewTensor.SubtractOperation((QsTensor)iTensor.AddOperation(value));
}
}
else
{
for (int il = 0; il < this.MatrixLayers.Count; il++)
{
QsMatrix ResultMatrix = (QsMatrix)this.MatrixLayers[il].SubtractOperation(scalar);
NewTensor.AddMatrix(ResultMatrix);
}
}
return(NewTensor);
}
if (value is QsTensor)
{
var tensor = value as QsTensor;
if (this.Order != (tensor.Order))
{
throw new QsException("Adding two different ranked tensors are not supported");
}
if (this.Order > 3)
{
QsTensor NewTensor = new QsTensor();
for (int i = 0; i < this.InnerTensors.Count(); i++)
{
var iTensor = this.InnerTensors[i];
NewTensor.AddInnerTensor((QsTensor)
iTensor.SubtractOperation(tensor.InnerTensors[i]));
}
return(NewTensor);
}
else
{
if (tensor.MatrixLayers.Count == this.MatrixLayers.Count)
{
// the operation will succeed
if (tensor.FaceRowsCount == this.FaceRowsCount)
{
if (tensor.FaceColumnsCount == this.FaceColumnsCount)
{
QsTensor NewTensor = new QsTensor();
for (int il = 0; il < this.MatrixLayers.Count; il++)
{
QsMatrix ResultMatrix = (QsMatrix)this.MatrixLayers[il].SubtractOperation(tensor.MatrixLayers[il]);
NewTensor.AddMatrix(ResultMatrix);
}
return(NewTensor);
}
}
}
}
}
throw new QsException("Tensor Subtract Operation with " + value.GetType().Name + " Failed");
}
/// <summary>
/// Create A matrix from a row values by aligning values to the left in
/// </summary>
/// <param name="values"></param>
/// <returns></returns>
public static QsValue MatrixRowFromValues(params QsValue[] values)
{
// what about [g g] and g is tensor
// in this case return value should be tensor
// from the higher degree of above g
if (values[0] is QsTensor)
{
if (values.Count() == 1)
{
return(values[0]);
}
// in rare cases or event known cases by me Ahmed Sadek and because of parsing
// sometimes I enclose tensor variable inside matrix [g g <|4 3|> ]
// so in this case i will the return as it is.
QsTensor tensor = new QsTensor();
foreach (var inTensor in values)
{
if (inTensor.GetType() != typeof(QsTensor))
{
throw new QsException("Non Tensor in a matrix of tensors is not valid expression.");
}
else
{
tensor.AddInnerTensor((QsTensor)inTensor);
}
}
return(tensor);
}
QsMatrix m = new QsMatrix();
foreach (var v in values)
{
if (v is QsScalar)
{
if (m.RowsCount == 0)
{
m.AddVector((QsVector)VectorFromValues(v));
}
else
{
m.Rows[0].AddComponent((QsScalar)v);
}
}
if (v is QsVector)
{
if (m.RowsCount == 0)
{
m.AddVector(((QsVector)v).Clone() as QsVector);
}
else if (m.RowsCount == 1)
{
m.Rows[0].AddComponents((QsVector)v);
}
else
{
throw new QsInvalidOperationException("Couldn't adding vector to multi row matrix");
}
}
if (v is QsMatrix)
{
if (m.RowsCount == 0)
{
m = null;
m = QsMatrix.CopyMatrix((QsMatrix)v);
}
else if (m.RowsCount == ((QsMatrix)v).RowsCount)
{
foreach (var col in ((QsMatrix)v).Columns)
{
m.AddColumnVector(col);
}
}
else
{
throw new QsInvalidOperationException("Couldn't adding different row matrices");
}
}
}
return(m);
}
public override QsValue MultiplyOperation(QsValue vl)
{
QsValue value;
if (vl is QsReference)
{
value = ((QsReference)vl).ContentValue;
}
else
{
value = vl;
}
if (value is QsScalar)
{
var scalar = (QsScalar)value;
QsTensor NewTensor = new QsTensor();
if (this.Order > 3)
{
foreach (var iTensor in this.InnerTensors)
{
NewTensor.AddInnerTensor((QsTensor)iTensor.MultiplyOperation(value));
}
}
else
{
for (int il = 0; il < this.MatrixLayers.Count; il++)
{
QsMatrix ResultMatrix = (QsMatrix)this.MatrixLayers[il].MultiplyOperation(scalar);
NewTensor.AddMatrix(ResultMatrix);
}
}
return(NewTensor);
}
if (value is QsTensor)
{
var tensor = (QsTensor)value;
if (this.Order == 1 && tensor.Order == 1)
{
var thisVec = this[0][0];
var thatVec = tensor[0][0];
var result = (QsMatrix)thisVec.TensorProductOperation(thatVec);
return(new QsTensor(result));
}
if (this.Order == 2 && tensor.Order <= 2)
{
//tenosrial product of two matrices will result in another matrix also.
QsMatrix result = (QsMatrix)this.MatrixLayers[0].TensorProductOperation(tensor.MatrixLayers[0]);
return(new QsTensor(result));
}
else
{
throw new QsException("", new NotImplementedException());
}
}
throw new QsException("Tensor Multiplication Operation with " + value.GetType().Name + " Failed");
}
