//CONJUGATE
public IComplexNumber Conjugate(IComplexNumber number)
{
double real = number.PartReal;
double complex = -number.PartComplex;
return ComplexNumberFactory.GenerateComplexNumber(real, complex);
}
static void ComplexNumberArithmetics(IComplexNumber channel, Complex z1, Complex z2, IMessenger messenger)
{
try
{
var builder = new StringBuilder();
builder.AppendFormat("\n*** Complex Number Arithmetics ***\n\n");
builder.AppendFormat("{0} + {1} = {2}\n", f(z1), f(z2), f(channel.Add(z1, z2)));
builder.AppendFormat("{0} - {1} = {2}\n", f(z1), f(z2), f(channel.Subtract(z1, z2)));
builder.AppendFormat("{0} * {1} = {2}\n", f(z1), f(z2), f(channel.Multiply(z1, z2)));
builder.AppendFormat("{0} / {1} = {2}\n", f(z1), f(z2), f(channel.Divide(z1, z2)));
builder.AppendFormat("Conjugate[{0}] = {1}\n", f(z1), f(channel.Conjugate(z1)));
builder.AppendFormat("Conjugate[{0}] = {1}\n", f(z2), f(channel.Conjugate(z2)));
builder.AppendFormat("Recipocal[{0}] = {1}\n", f(z1), f(channel.Recipocal(z1)));
builder.AppendFormat("Recipocal[{0}] = {1}\n", f(z2), f(channel.Recipocal(z2)));
builder.AppendFormat("Modulus[{0}] = {1}\n", f(z1), channel.Modulus(z1));
builder.AppendFormat("Modulus[{0}] = {1}\n", f(z2), channel.Modulus(z2));
builder.AppendFormat("Argument[{0}] = {1} Radians\n", f(z1), channel.Argument(z1));
builder.AppendFormat("Argument[{0}] = {1} Radians\n", f(z2), channel.Argument(z2));
var msg = builder.ToString();
Console.WriteLine(msg);
messenger.SendMessage(msg);
}
catch (Exception fx)
{
Console.WriteLine(fx.Message);
}
}
public IComplexNumber Multiplication(IComplexNumber number, double factor)
{
double real = number.getPartReal() * factor;
double complex = number.getPartComplex() * factor;
return FactoryComplexNumber.GenerateComplexNumber(real, complex);
}
//INVERSE
public IComplexNumber Inverse(IComplexNumber number)
{
double real = 1 / number.PartReal;
double complex = 1 / number.PartComplex;
return ComplexNumberFactory.GenerateComplexNumber(real, complex);
}
//INVERSE
public IComplexNumber Inverse(IComplexNumber number)
{
double real = 1 / number.getPartReal();
double complex = 1 / number.getPartComplex();
return FactoryComplexNumber.GenerateComplexNumber(real, complex);
}
//CONJUGATE
public IComplexNumber Conjugate(IComplexNumber number)
{
double real = number.getPartReal();
double complex = -number.getPartComplex();
return FactoryComplexNumber.GenerateComplexNumber(real, complex);
}
private IStudyAssignment Adder(IComplexNumber addend, AdderArgument type)
{
var result = new ComplexNumber(RealPart + addend.RealPart * (int)type,
ImaginaryPart + addend.ImaginaryPart * (int)type);
return(result);
}
//ADDITION
public IComplexNumber Add(IComplexNumber numberA, IComplexNumber numberB)
{
double real = numberA.getPartReal() + numberB.getPartReal();
double complex = numberA.getPartComplex() + numberB.getPartComplex();
return FactoryComplexNumber.GenerateComplexNumber(real, complex);
}
// No Initialization is needed on grouth
//SIZE MANAGEMENT
public override void setSize(int numRows, int numCols, bool initializate)
{
int maxRow = System.Math.Min(getNumRows(),numRows);
int maxCol = System.Math.Min(getNumCols(),numCols);
IComplexNumber[,] tempMatrix = new IComplexNumber[numRows,numCols];
for( int i=0; i < maxRow; i++ )
{
for( int j=0; j < maxCol; j++ )
{
tempMatrix[i,j] = _internalMatrix[i,j];
}
// rest of rows
// if (initializate)
// for( int j=maxCol; j < numCols; j++)
// {
// tempMatrix[i,j] = ComplexNumberFactory.generateComplexNumber();
// }
}
// full aditional rows
// if (initializate)
// for( int i=maxRow; i < numRows; i++)
// {
// for( int j=0; j < numCols; j++ )
// {
// tempMatrix[i,j] = ComplexNumberFactory.generateComplexNumber();
// }
// }
_internalMatrix = tempMatrix;
}
//DIVISION
public IComplexNumber Division(IComplexNumber numberA, IComplexNumber numberB)
{
// a+bi * c+di
// ac+bci+adi+bdi^2
// ac+bci+adi-bd
// ac-bd+bci+adi
// (ac-bd)+(bc+ad)i
IComplexNumber inverse = FactoryComplexNumber.Operations.Inverse(numberB);
return FactoryComplexNumber.Operations.Multiplication(numberA, inverse);
}
//ELEMENTS MANAGEMENT
public override void setElement(IComplexNumber element, int posRows, int posCols)
{
if (element == null)
{ _internalMatrix[posRows,posCols] = null; }
else
{
if (element.IsZero())
{ _internalMatrix[posRows,posCols] = null; }
else
{ _internalMatrix[posRows,posCols] = element; }
}
}
static void ComplexNumberArithmetics(IComplexNumber channel, ComplexNumber z1, ComplexNumber z2)
{
try
{
Console.WriteLine("{0} + {1} = {2}", f(z1), f(z2), f(channel.Add(z1, z2)));
Console.WriteLine("{0} - {1} = {2}", f(z1), f(z2), f(channel.Subtract(z1, z2)));
Console.WriteLine("{0} * {1} = {2}", f(z1), f(z2), f(channel.Multiply(z1, z2)));
Console.WriteLine("{0} / {1} = {2}", f(z1), f(z2), f(channel.Divide(z1, z2)));
}
catch (Exception fx)
{
Console.WriteLine(fx.Message);
}
}
//MULTIPLICATION
public IComplexNumber Multiplication(IComplexNumber numberA, IComplexNumber numberB)
{
// a+bi * c+di
// ac+bci+adi+bdi^2
// ac+bci+adi-bd
// ac-bd+bci+adi
// (ac-bd)+(bc+ad)i
//
// http://mathworld.wolfram.com/ComplexMultiplication.html
double real = numberA.getPartReal() * numberB.getPartReal() - numberA.getPartComplex() * numberB.getPartComplex();
double complex = numberA.getPartComplex() * numberB.getPartReal() + numberA.getPartReal() * numberB.getPartComplex();
return FactoryComplexNumber.GenerateComplexNumber(real, complex);
}
public override void setElement(IComplexNumber element, int posRows, int posCols)
{
string key = generateKey(posRows,posCols);
if (element == null)
//{ _internalMatrix[key] = null; }
{ _internalMatrix.Remove(key); }
else
{
if (element.IsZero())
//{ _internalMatrix[key] = null; }
{ _internalMatrix.Remove(key); }
else
{ _internalMatrix[key] = element; }
}
}
static void ComplexNumberArithmetics(IComplexNumber channel, ComplexNumber z1, ComplexNumber z2)
{
try
{
Console.WriteLine("{0} + {1} = {2}", f(z1), f(z2), f(channel.Add(z1, z2)));
Console.WriteLine("{0} - {1} = {2}", f(z1), f(z2), f(channel.Subtract(z1, z2)));
Console.WriteLine("{0} * {1} = {2}", f(z1), f(z2), f(channel.Multiply(z1, z2)));
Console.WriteLine("{0} / {1} = {2}", f(z1), f(z2), f(channel.Divide(z1, z2)));
Console.WriteLine("Conjugate[{0}] = {1}", f(z1), f(channel.Conjugate(z1)));
Console.WriteLine("Reciprocal[{0}] = {1}", f(z1), f(channel.Reciprocal(z1)));
Console.WriteLine("Modulus[{0}] = {1}", f(z1), channel.Modulus(z1));
Console.WriteLine("Argument[{0}] = {1} Radians", f(z1), channel.Argument(z1));
}
catch (Exception fx)
{
Console.WriteLine(fx.Message);
}
}
//protected internal override IComplexNumber getCoefficientNormalized(int pos)
//{
// int rest;
// IQuantumStateDebugger debugger = findStateDebugger(pos, out rest);
// return debugger.getCoefficientNormalized(rest);
//}
protected internal override void setCoefficientInternal(IComplexNumber coefficient, int pos)
{
int count = getNumLevels();
int rest = count;
IQuantumState item;
IQuantumStateDebugger debugger;
int temp;
for (int i = 0; i < count; i++)
{
item = (IQuantumState)_collection.getObject(i);
debugger = item.Debugger;
temp = debugger.getNumLevels();
if (temp > rest)
{
rest = rest - temp;
}
else
{
debugger.setCoefficientInternal(coefficient, rest);
}
}
}
public IStudyAssignment Multiply(IComplexNumber factor)
{
return(new ComplexNumber(RealPart * factor.RealPart -
ImaginaryPart * factor.ImaginaryPart,
ImaginaryPart * factor.RealPart + RealPart * factor.ImaginaryPart));
}
// UTILITY PRODUCT
public IComplexMatrix Multiplication(IComplexNumber number, IComplexMatrix matrix)
{
int maxRow = matrix.getNumRows();
int maxCol = matrix.getNumCols();
IComplexMatrix resultMatrix = ComplexMatrixFactory.GenerateComplexMatrix(maxRow, maxCol, false);
IComplexNumber coefficient;
for (int i = 0; i < maxRow; i++)
{
for (int j = 0; j < maxCol; j++)
{
coefficient = ComplexNumberFactory.Operations.Multiplication(number, matrix.getElement(i, j));
resultMatrix.setElement(coefficient, i, j);
}
}
return resultMatrix;
}
/// <summary>
/// Сумма двух комлпексных чисел
/// </summary>
/// <param name="addend">слагаемое</param>
/// <returns>Новый объект</returns>
public IStudyAssignment Add(IComplexNumber addend)
{
return(Adder(addend, AdderArgument.Add));
}
//DATA ACCESS
public override void setElement(IComplexNumber element, int posRows, int posCols)
{
_internalMatrix[posRows,posCols] = element;
}
protected internal override void setCoefficientInternal(IComplexNumber coefficient, int pos)
{
_matrix.setElement(coefficient, pos, 0);
}
public double Norm(IComplexNumber number)
{
return NormEuclidean(number);
}
//MULTIPLICATION
private IComplexNumber Multiplication2(IComplexNumber numberA, IComplexNumber numberB)
{
// (a+bi) * (c+di)
// ac+bci+adi+bdi^2
// ac+bci+adi-bd
// ac-bd+bci+adi
// (ac-bd)+(bc+ad)i
//
// http://mathworld.wolfram.com/ComplexMultiplication.html
double real = numberA.PartReal * numberB.PartReal - numberA.PartComplex * numberB.PartComplex;
double complex = numberA.PartComplex * numberB.PartReal + numberA.PartReal * numberB.PartComplex;
return ComplexNumberFactory.GenerateComplexNumber(real, complex);
}
protected internal override void setCoefficientInternal(IComplexNumber coefficient, int pos)
{
throw new NotImplementedException();
}
public double PoweredNormEuclidean(IComplexNumber number)
{
// http://mathworld.wolfram.com/ComplexModulus.html
double coefA = System.Math.Pow(number.PartReal, 2);
double coefB = System.Math.Pow(number.PartComplex, 2);
return coefA + coefB; // nada de restas ni de valores absolutos
}
//SIGN REVERSAL
public IComplexNumber SignReversal(IComplexNumber number)
{
double real = -number.PartReal;
double complex = -number.PartComplex;
return ComplexNumberFactory.GenerateComplexNumber(real, complex);
}
// NORM
public double PoweredNorm(IComplexNumber number)
{
return PoweredNormEuclidean(number);
}
public double NormEuclidean(IComplexNumber number)
{
return System.Math.Sqrt(PoweredNormEuclidean(number));
}
//CATEGORIZATION
public bool Equals(IComplexNumber number)
{
return ((this.getPartReal().Equals(number.getPartReal())) && (this.getPartComplex().Equals(number.getPartComplex())));
}
public IComplexNumber[] extractAsArray()
{
int count = countTotalElements();
IComplexNumber[] result = new IComplexNumber[count];
for (int i=0; i < getNumRows(); i++)
{
for (int j = 0; j < getNumCols(); j++)
{
result[i + j] = getElement(i, j);
}
}
return result;
}
//ELEMENTS MANAGEMENT public abstract void setElement(IComplexNumber element, int posRows, int posCols);
public IComplexNumber[] getDiagonal2()
{
int length = System.Math.Min(getNumRows(),getNumCols());
IComplexNumber[] result = new IComplexNumber[length];
IComplexNumber coefficient;
//Iterate over rows
for( int k=0; k < length; k++ )
{
coefficient = this.getElement(k,getNumCols()-k);
result[k] = coefficient;
}
return result;
}
protected internal override void setCoefficientInternal(IComplexNumber coefficient, int pos)
{
_internalState.generateQuantumDebugger().setCoefficientInternal(coefficient, pos);
}
public void Initialize(IComplexNumber number)
{
setPartReal ( number.getPartReal() );
setPartComplex( number.getPartComplex() );
}
/// <summary>
/// Разность комплексных чисел
/// </summary>
/// <param name="subtrahend">Вычитаемое</param>
/// <returns>новый объект</returns>
///
public IStudyAssignment Sub(IComplexNumber subtrahend)
{
return(Adder(subtrahend, AdderArgument.Sub));
}
