📄 sparsenumbertoken.java
字号:
{
StringBuffer buffer = new StringBuffer(20);
for(int yy = 0; yy < sizeY; yy++)
{
buffer.append("[");
for(int xx = 0; xx < sizeX; xx++)
{
buffer.append(toString(values[yy][xx]));
if(xx < sizeX - 1)
buffer.append(" , ");
}
buffer.append("]\n");
}
result = new String(buffer);
}
return result;
}
/** create string representation of (complex) double values
@param _values[]={REAL,IMAGINARY} real and imaginary part of number*/
public String toString(double _values[])
{
double re = _values[REAL];
double im = _values[IMAGINARY];
StringBuffer result = new StringBuffer();
if((im != 0.0) || Double.isNaN(im))
result.append("(");
// real part of number
// +/- infinity, not a number, number
if (re == Double.POSITIVE_INFINITY)
result.append("Inf");
else if (re == Double.NEGATIVE_INFINITY)
result.append("-Inf");
else if (Double.isNaN(re))
result.append("NaN");
else
result.append(numFormat.format(re));
// imaginary part of number
if((im != 0.0) || Double.isNaN(im))
{
if ((re!=0.0) && !(im<0))
result.append("+");
// +/- infinity, not a number, number
if (im == Double.POSITIVE_INFINITY)
result.append("Inf");
else if (im == Double.NEGATIVE_INFINITY)
result.append("-Inf");
else if (Double.isNaN(im))
result.append("NaN");
else
result.append(numFormat.format(im));
result.append("i)");
}
return result.toString();
}
/**Evaluate the token. This causes it to return itself*/
public OperandToken evaluate(Token[] operands)
{
return this;
}
/**Check if two tokens are equal
@param arg = the object to check against*/
public boolean equals(Object arg)
{
if(arg instanceof DoubleNumberToken)
{
DoubleNumberToken nArg = (DoubleNumberToken)arg;
if(sizeX == nArg.getSizeX() && sizeY == nArg.getSizeY())
{
boolean equal = true;
for (int yy=0; yy<sizeY && equal; yy++)
{
for (int xx=0; xx<sizeX && equal; xx++)
{
if((values[yy][xx][REAL] - nArg.getValueRe(yy, xx) != 0) ||
(values[yy][xx][IMAGINARY] - nArg.getValueIm(yy, xx) != 0))
equal = false;
}
}
return equal;
}
return false;
}
return false;
}
/**calculate the arg of the complex number at y, x*/
public double arg(int y, int x)
{
return Math.atan2(values[y][x][REAL], values[y][x][IMAGINARY]);
}
///////////////////////standard operators///////////////////
////////////////////////////////////////////////////////////
/**add arg to this object for a number token
@param = the value to add to it
@return the result as an OperandToken*/
public OperandToken add(OperandToken arg)
{
if(!(arg instanceof DoubleNumberToken))
Errors.throwMathLibException("DoubleNumberToken: add: no number");
DoubleNumberToken nArg = ((DoubleNumberToken)arg);
int argSizeX = nArg.getSizeX();
int argSizeY = nArg.getSizeY();
// Check dimensions of matrices
if((sizeX == argSizeX) && (sizeY == argSizeY))
{
// Add (n*m) + (n*m)
ErrorLogger.debugLine("DoubleNumberToken: add (n*m) + (n*m)");
DoubleNumberToken result = new DoubleNumberToken(values);
for(int yy = 0; yy < sizeY; yy++)
{
for(int xx = 0; xx < sizeX; xx++)
{
double realval = values[yy][xx][REAL] + nArg.getValueRe(yy, xx);
double imaginaryval = values[yy][xx][IMAGINARY] + nArg.getValueIm(yy, xx);
result.setValue(yy, xx, realval, imaginaryval);
}
}
//ErrorLogger.debugLine("end DoubleNumberToken: add (n*m) + (n*m)");
return result;
}
else if((sizeX==1) && (sizeY==1))
{
// 1 + [3,4,5]
ErrorLogger.debugLine("DoubleNumberToken: add (1*1) + (n*m)");
DoubleNumberToken result = nArg;
double re = getValueRe(0, 0);
double im = getValueIm(0, 0);
for(int yy = 0; yy < argSizeY; yy++)
{
for(int xx = 0; xx < argSizeX; xx++)
{
double realval = nArg.getValueRe(yy,xx) + re;
double imaginaryval = nArg.getValueIm(yy,xx) + im;
result.setValue(yy, xx, realval, imaginaryval);
}
}
//ErrorLogger.debugLine("end DoubleNumberToken: add (n*m) + (n*m)");
return result;
}
else if((argSizeX==1) && (argSizeY==1))
{
// [3,4,5] +1
ErrorLogger.debugLine("DoubleNumberToken: add (n,m) + (1,1)");
DoubleNumberToken result = new DoubleNumberToken(values);
double re = nArg.getValueRe(0, 0);
double im = nArg.getValueIm(0, 0);
for(int yy = 0; yy < sizeY; yy++)
{
for(int xx = 0; xx < sizeX; xx++)
{
double realval = values[yy][xx][REAL] + re;
double imaginaryval = values[yy][xx][IMAGINARY] + im;
result.setValue(yy, xx, realval, imaginaryval);
}
}
//ErrorLogger.debugLine("end DoubleNumberToken: add (n*m) + (n*m)");
return result;
}
else
{
/* Matrices have unequal size: (n*m) != (o*p) */
Errors.throwMathLibException("DoubleNumberToken: add matrices of unequal size");
return null;
}
} // and add
/**subtract arg from this object for a number token
@param = the value to subtract
@return the result as an OperandToken*/
public OperandToken subtract(OperandToken arg)
{
if(!(arg instanceof DoubleNumberToken))
Errors.throwMathLibException("DoubleNumberToken: substract: no number");
DoubleNumberToken nArg = ((DoubleNumberToken)arg);
int argSizeX = nArg.getSizeX();
int argSizeY = nArg.getSizeY();
//Check dimensions of matrices
if((sizeX == argSizeX) && (sizeY == argSizeY))
{
// Sub (n*m) - (n*m)
ErrorLogger.debugLine("DoubleNumberToken: sub (n*m) - (n*m)");
DoubleNumberToken result = new DoubleNumberToken(values);
for(int yy = 0; yy < sizeY; yy++)
{
for(int xx = 0; xx < sizeX; xx++)
{
double realval = values[yy][xx][REAL] - nArg.getValueRe(yy, xx);
double imaginaryval = values[yy][xx][IMAGINARY] - nArg.getValueIm(yy, xx);
result.setValue(yy, xx, realval, imaginaryval);
}
}
return result;
}
else if((sizeX == 1) && (sizeY == 1))
{
// 1 - [2,3,4]
ErrorLogger.debugLine("DoubleNumberToken: sub (1*1) - (n*m)");
DoubleNumberToken result = nArg;
double re = getValueRe(0, 0);
double im = getValueIm(0, 0);
for(int yy = 0; yy < argSizeY; yy++)
{
for(int xx = 0; xx < argSizeX; xx++)
{
double realval = re - nArg.getValueRe(yy,xx);
double imaginaryval = im - nArg.getValueIm(yy,xx);
result.setValue(yy, xx, realval, imaginaryval);
}
}
return result;
}
else if((argSizeX == 1) && (argSizeY == 1))
{
// [3,4,5] - 5
ErrorLogger.debugLine("DoubleNumberToken: sub (n*m) - (1*1)");
DoubleNumberToken result = new DoubleNumberToken(values);
double re = nArg.getValueRe(0, 0);
double im = nArg.getValueIm(0, 0);
for(int yy = 0; yy < sizeY; yy++)
{
for(int xx = 0; xx < sizeX; xx++)
{
double realval = values[yy][xx][REAL] - re;
double imaginaryval = values[yy][xx][IMAGINARY] - im;
result.setValue(yy, xx, realval, imaginaryval);
}
}
return result;
}
else
{
// Matrices have unequal size: (n*m) != (o*p)
ErrorLogger.debugLine("DoubleNumberToken: sub matrices of unequal size");
return null;
}
}
/**Raise this object to the power of arg
@param = the value to raise it to the power of
@return the result as an OperandToken*/
public OperandToken power(OperandToken arg)
{
// works only on numbers
if(!(arg instanceof DoubleNumberToken))
Errors.throwMathLibException("DoubleNumberToken: powerOf: no number");
//double[][] argValuesImg = ((DoubleNumberToken)arg).getValuesImg();
int argSizeX = ((DoubleNumberToken)arg).getSizeX();
int argSizeY = ((DoubleNumberToken)arg).getSizeY();
if ((sizeX==1) && (sizeY==1))
{
// e.g. [1,2,3;4,5,6].^4
double [][][]results = new double[sizeY][sizeX][2];
// bug in Z()-class: 0^something equals 0
if (values[0][0][REAL] == 0 && values[0][0][IMAGINARY] == 0)
return zero;
double[] argValues = ((DoubleNumberToken)arg).getValueComplex(0, 0);
//Complex result = Z.pow(values.get(0,0), argValues.get(0, 0));
double re = Math.log(getValueAbs(0, 0));
double im = getValueArg(0, 0);
double re2 = (re*argValues[REAL]) - (im*argValues[IMAGINARY]);
double im2 = (re*argValues[IMAGINARY]) + (im*argValues[REAL]);
double scalar = Math.exp(re2);
results[0][0][REAL] = scalar * Math.cos(im2);
results[0][0][IMAGINARY] = scalar * Math.sin(im2);
return new DoubleNumberToken(results);
}
else if ((argSizeX==1) && (argSizeY==1))
{
// e.g. [1,2,3;4,5,6].^2
}
Errors.throwMathLibException("DoubleNumberToken: power invalid array");
return null;
} // end powerOf
/**multiply arg by this object for a number token
@param arg = the value to multiply it by
@return the result as an OperandToken*/
public OperandToken multiply(OperandToken arg)
{
if(!(arg instanceof DoubleNumberToken))
Errors.throwMathLibException("DoubleNumberToken: multiply: no number");
DoubleNumberToken argValues = ((DoubleNumberToken)arg);
int argSizeX = ((DoubleNumberToken)arg).getSizeX();
int argSizeY = ((DoubleNumberToken)arg).getSizeY();
/* Check if arg is a scalar */
if((argSizeX == 1) && (argSizeY == 1))
{
// Multiply (n*m) = (n*m) * scalar
ErrorLogger.debugLine("DoubleNumberToken: multiply ("+sizeY+"*"+sizeX+") * scalar");
double [][][]results = new double[sizeY][sizeX][2];
double argRe = argValues.getValueRe();
double argIm = argValues.getValueIm();
for (int yy=0; yy<sizeY; yy++)
{
for (int xx=0; xx<sizeX; xx++)
{
double temp = values[yy][xx][REAL] * argRe
- values[yy][xx][IMAGINARY] * argIm;
results[yy][xx][IMAGINARY] = values[yy][xx][IMAGINARY] * argRe
+ values[yy][xx][REAL] * argIm;
results[yy][xx][REAL] = temp;
}
}
return new DoubleNumberToken(results);
}
else if((sizeX == 1) && (sizeY == 1))
{
/* the DoubleNumberToken of this class is a scalar */
/* Multiply (n*m) = scalar * (n*m) */
ErrorLogger.debugLine("DoubleNumberToken: multiply scalar * (n*m) ");
//argValues = argValues.times(values.get(0,0));
//values[0][0] = multiply(values[0][0], argValues.getValueComplex(0, 0));
return arg.multiply(this);
}
else if (sizeX == argSizeY)
{
/* Multiply (n*o) = (n*m) * (m*o) */
ErrorLogger.debugLine("DoubleNumberToken: multiply (n*m) * (m*o)");
//Zmat resultValues = values.times(argValues);
double[][][] results = new double[sizeY][argSizeX][2];
for(int i=0; i<sizeY; i++)
{
for (int k=0; k<argSizeX; k++)
{
results[i][k][REAL] = 0;
results[i][k][IMAGINARY] = 0;
for (int j=0; j<sizeX; j++)
{
double temp[] = multiply(values[i][j], argValues.getValueComplex(j, k));
results[i][k][REAL] += temp[REAL];
results[i][k][IMAGINARY] += temp[IMAGINARY];
}
}
}
return new DoubleNumberToken(results);
}
else
{
/* dimensions do not match */
ErrorLogger.debugLine("DoubleNumberToken: multiply: dimensions don't match");
return null;
}
} // end multiply
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -