📄 doublenumbertoken.java
字号:
// transform: double + int8 into int8 + double
Int8NumberToken nArg = ((Int8NumberToken)arg);
return nArg.add(this);
}
else if(arg instanceof CharToken)
{
// 2+'a b'
CharToken nArg = ((CharToken)arg);
_double d = new _double();
DoubleNumberToken numT = (DoubleNumberToken)d.evaluate(new OperandToken[]{nArg});
return this.add(numT);
}
Errors.throwMathLibException("DoubleNumberToken: add: no number");
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);
//Check dimensions of matrices
if( checkEqualDimensions(this.sizeA, nArg.sizeA) )
{
// Sub (n*m) - (n*m) or
// multidimensional (n*m*r) - (n*m*r)
ErrorLogger.debugLine("DoubleNumberToken: sub (n*m) - (n*m)");
DoubleNumberToken result = new DoubleNumberToken(sizeA, null, null);
for(int n = 0; n < noElem; n++)
{
double realval = getValueRe(n) - nArg.getValueRe(n);
double imaginaryval = getValueIm(n) - nArg.getValueIm(n);
result.setValue(n, realval, imaginaryval);
}
return result;
}
else if( isScalar() )
{
// 1 - [2,3,4]
ErrorLogger.debugLine("DoubleNumberToken: sub (1*1) - (n*m)");
DoubleNumberToken result = new DoubleNumberToken(nArg.sizeA, null, null);
for(int n = 0; n < nArg.getNumberOfElements(); n++)
{
double realval = getValueRe() - nArg.getValueRe(n);
double imaginaryval = getValueIm() - nArg.getValueIm(n);
result.setValue(n, realval, imaginaryval);
}
return result;
}
else if( nArg.isScalar() )
{
// [3,4,5] - 5
ErrorLogger.debugLine("DoubleNumberToken: sub (n*m) - (1*1)");
DoubleNumberToken result = new DoubleNumberToken(sizeA, null, null);
for(int n = 0; n < noElem; n++)
{
double realval = values[n][REAL] - nArg.getValueRe();
double imaginaryval = values[n][IMAG] - nArg.getValueIm();
result.setValue(n, realval, imaginaryval);
}
return result;
}
else
{
// Matrices have unequal size: (n*m) != (o*p)
Errors.throwMathLibException("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");
// get operand data and size
DoubleNumberToken nArg = (DoubleNumberToken)arg;
double[][] argValuesRe = ((DoubleNumberToken)arg).getValuesRe();
double[][] argValuesIm = ((DoubleNumberToken)arg).getValuesIm();
int argSizeX = ((DoubleNumberToken)arg).getSizeX();
int argSizeY = ((DoubleNumberToken)arg).getSizeY();
if ( this.isScalar() )
{
// e.g. 4.^[1,2,3;4,5,6]
// return values
double [][][]results = new double[argSizeY][argSizeX][2];
for (int y=0; y<argSizeY; y++)
{
for (int x=0; x<argSizeX; x++)
{
double re = Math.log(getValueAbs(0, 0));
double im = getValueArg(0, 0);
double re2 = (re*argValuesRe[y][x]) - (im*argValuesIm[y][x]);
double im2 = (re*argValuesIm[y][x]) + (im*argValuesRe[y][x]);
double scalar = Math.exp(re2);
results[y][x][REAL] = scalar * Math.cos(im2);
results[y][x][IMAG] = scalar * Math.sin(im2);
}
}
return new DoubleNumberToken(results);
}
else if ( nArg.isScalar() )
{
// e.g. [1,2,3;4,5,6].^2
// return values
double [][][]results = new double[sizeY][sizeX][2];
for (int y=0; y<sizeY; y++)
{
for (int x=0; x<sizeX; x++)
{
double re = Math.log(getValueAbs(y, x));
double im = getValueArg(y, x);
double re2 = (re*argValuesRe[0][0]) - (im*argValuesIm[0][0]);
double im2 = (re*argValuesIm[0][0]) + (im*argValuesRe[0][0]);
double scalar = Math.exp(re2);
results[y][x][REAL] = scalar * Math.cos(im2);
results[y][x][IMAG] = scalar * Math.sin(im2);
}
}
return new DoubleNumberToken(results);
}
else if ( checkEqualDimensions(this.sizeA, nArg.sizeA) )
{
// e.g. [1,2,3;4,5,6].^[3,4,5;6,7,8]
// return values
double [][][]results = new double[sizeY][sizeX][2];
for (int y=0; y<sizeY; y++)
{
for (int x=0; x<sizeX; x++)
{
double re = Math.log(getValueAbs(y, x));
double im = getValueArg(y, x);
double re2 = (re*argValuesRe[y][x]) - (im*argValuesIm[y][x]);
double im2 = (re*argValuesIm[y][x]) + (im*argValuesRe[y][x]);
double scalar = Math.exp(re2);
results[y][x][REAL] = scalar * Math.cos(im2);
results[y][x][IMAG] = scalar * Math.sin(im2);
}
}
return new DoubleNumberToken(results);
}
Errors.throwMathLibException("DoubleNumberToken: .^ dimensions do not fit");
return null;
} // end powerOf
/** The value to raise it to the matrix power of
* @param arg
* @return
*/
public OperandToken mPower(OperandToken arg)
{
// works only on numbers
if(!(arg instanceof DoubleNumberToken))
Errors.throwMathLibException("DoubleNumberToken: mPower: no number");
// get operand data and size
DoubleNumberToken nArg = (DoubleNumberToken)arg;
double[][] argValuesRe = ((DoubleNumberToken)arg).getValuesRe();
double[][] argValuesIm = ((DoubleNumberToken)arg).getValuesIm();
int argSizeX = ((DoubleNumberToken)arg).getSizeX();
int argSizeY = ((DoubleNumberToken)arg).getSizeY();
if (this.isScalar() && (argSizeX==1) && (argSizeY==1))
{
// e.g. 4.^5
// return values
double [][][]results = new double[1][1][2];
double re = Math.log(getValueAbs(0, 0));
double im = getValueArg(0, 0);
double re2 = (re*argValuesRe[0][0]) - (im*argValuesIm[0][0]);
double im2 = (re*argValuesIm[0][0]) + (im*argValuesRe[0][0]);
double scalar = Math.exp(re2);
results[0][0][REAL] = scalar * Math.cos(im2);
results[0][0][IMAG] = scalar * Math.sin(im2);
return new DoubleNumberToken(results);
}
else if ((sizeX==sizeY) && (argSizeX==1) && (argSizeY==1))
{
// [2,3;4,5]^9
Errors.throwMathLibException("DoubleNumberToken: mPower: [n*n]^scalar not implemented yet");
return null;
}
else if ((sizeX==1) && (sizeY==1) && (argSizeX==argSizeY))
{
// 9^[2,3;4,5]
Errors.throwMathLibException("DoubleNumberToken: mPower: scalar^[n*n] not implemented yet");
return null;
}
Errors.throwMathLibException("DoubleNumberToken: mPower: [n*m]^[o*p] not supported");
return null;
} // end matrixPower
/**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 nArg = (DoubleNumberToken)arg;
DoubleNumberToken argValues = ((DoubleNumberToken)arg);
int argSizeX = ((DoubleNumberToken)arg).getSizeX();
int argSizeY = ((DoubleNumberToken)arg).getSizeY();
/* Check if arg is a scalar */
if( nArg.isScalar() )
{
// 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++)
{
int n = yx2n(yy,xx);
double temp = values[n][REAL] * argRe
- values[n][IMAG] * argIm;
results[yy][xx][IMAG] = values[n][IMAG] * argRe
+ values[n][REAL] * argIm;
results[yy][xx][REAL] = temp;
}
}
return new DoubleNumberToken(results);
}
else if( this.isScalar() )
{
/* 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 && (sizeA.length==2))
{
/* 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][IMAG] = 0;
for (int j=0; j<sizeX; j++)
{
int n = yx2n(i,j);
double temp[] = multiply(values[n], argValues.getValueComplex(j, k));
results[i][k][REAL] += temp[REAL];
results[i][k][IMAG] += temp[IMAG];
}
}
}
return new DoubleNumberToken(results);
}
else
{
/* dimensions do not match */
Errors.throwMathLibException("DoubleNumberToken: multiply: dimensions don't match");
return null;
}
} // end multiply
/**Multiplies two complex numbers
@param arg1 = the first complex number as an array of double
@param arg2 = the second complex number as an array of double
@return the result as an array of double*/
public double[] multiply(double[] arg1, double[]arg2)
{
double[] temp = new double[2];
temp[REAL] = (arg1[REAL] * arg2[REAL]) - (arg1[IMAG] * arg2[IMAG]);
temp[IMAG] = (arg1[REAL] * arg2[IMAG]) + (arg1[IMAG] * arg2[REAL]);
return temp;
}
/**divide this object by arg for a number token
@param arg = the value to divide it by
@return the result as an OperandToken*/
public OperandToken divide(OperandToken arg)
{
if(!(arg instanceof DoubleNumberToken))
Errors.throwMathLibException("DoubleNumberToken: divide: no number");
DoubleNumberToken nArg = (DoubleNumberToken)arg;
int argSizeX = nArg.getSizeX();
int argSizeY = nArg.getSizeY();
// Check if arg is a scalar
if( nArg.isScalar() )
{
// Divide (n*m) = (n*m) / scalar
DoubleNumberToken result = new DoubleNumberToken(); //this);
result.setSize(sizeY, sizeX);
double[] argValue = nArg.getValueComplex(0, 0);
ErrorLogger.debugLine("DoubleNumberToken: divide (n*m) / scalar");
for (int yy=0; yy<sizeY; yy++)
{
for (int xx=0; xx<sizeX; xx++)
{
int n = yx2n(yy,xx);
result.setValueComplex(yy, xx, divide(values[n], argValue));
}
}
return result;
}
else if( this.isScalar() )
{
// the DoubleNumberToken of this class is a scalar
// Divide (n*m) = scalar / (n*m)
ErrorLogger.debugLine("DoubleNumberToken: divide scalar / (n*m) ");
DoubleNumberToken result = new DoubleNumberToken(1);
double[] value = values[0];
for (int yy=0; yy<argSizeY; yy++)
{
for (int xx=0; xx<argSizeX; xx++)
{
result.setValueComplex(yy, xx, divide(value, nArg.getValueComplex(yy, xx)));
}
}
return result;
}
else
{
Errors.throwMathLibException("DoubleNumberToken: divide: dimensions don't match");
return null;
}
} // end divide
/** divide two complex numbers and return a complex number again,
pay special attention to infinity and not a number
@param arg1 = the first complex number as an array of double
@param arg2 = the second complex number as an array of double
@return the result as an array of double*/
public double[] divide(double[] arg1, double[] arg2)
{
/* {REAL,IMAG} = divide( {REAL,IMAG}, {REAL,IMAG}) */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -