예제 #1
0
  public void estimate(final Access1D<?> x, final Access1D<?> y) {

    final int tmpRowDim = (int) Math.min(x.count(), y.count());
    final int tmpColDim = this.size();

    final PhysicalStore<ComplexNumber> tmpBody =
        ComplexDenseStore.FACTORY.makeZero(tmpRowDim, tmpColDim);
    final PhysicalStore<ComplexNumber> tmpRHS = ComplexDenseStore.FACTORY.makeZero(tmpRowDim, 1);

    for (int i = 0; i < tmpRowDim; i++) {

      ComplexNumber tmpX = ComplexNumber.ONE;
      final ComplexNumber tmpXfactor = ComplexNumber.valueOf((Number) x.get(i));
      final ComplexNumber tmpY = ComplexNumber.valueOf((Number) y.get(i));

      for (int j = 0; j < tmpColDim; j++) {
        tmpBody.set(i, j, tmpX);
        tmpX = tmpX.multiply(tmpXfactor);
      }
      tmpRHS.set(i, 0, tmpY);
    }

    final QR<ComplexNumber> tmpQR = QR.makeComplex();
    tmpQR.decompose(tmpBody);
    this.set(tmpQR.solve(tmpRHS));
  }
예제 #2
0
  public static void assertEquals(
      final String message,
      final Number expected,
      final Number actual,
      final NumberContext context) {

    if ((expected instanceof ComplexNumber) || (actual instanceof ComplexNumber)) {

      final ComplexNumber tmpExpected = ComplexNumber.valueOf(expected);
      final ComplexNumber tmpActual = ComplexNumber.valueOf(actual);

      if (!!context.isDifferent(tmpExpected.getReal(), tmpActual.getReal())) {
        Assert.failNotEquals(message + " (real)", expected, actual);
      }
      if (!!context.isDifferent(tmpExpected.getImaginary(), tmpActual.getImaginary())) {
        Assert.failNotEquals(message + " (imaginary)", expected, actual);
      }

    } else if ((expected instanceof Quaternion) || (actual instanceof Quaternion)) {

      final Quaternion tmpExpected = Quaternion.valueOf(expected);
      final Quaternion tmpActual = Quaternion.valueOf(actual);

      if (!!context.isDifferent(tmpExpected.scalar(), tmpActual.scalar())) {
        Assert.failNotEquals(message + " (scalar)", expected, actual);
      }
      if (!!context.isDifferent(tmpExpected.i, tmpActual.i)) {
        Assert.failNotEquals(message + " (i)", expected, actual);
      }
      if (!!context.isDifferent(tmpExpected.j, tmpActual.j)) {
        Assert.failNotEquals(message + " (j)", expected, actual);
      }
      if (!!context.isDifferent(tmpExpected.k, tmpActual.k)) {
        Assert.failNotEquals(message + " (k)", expected, actual);
      }

    } else {

      if (context.isDifferent(expected.doubleValue(), actual.doubleValue())) {
        Assert.failNotEquals(message, expected, actual);
      }
    }
  }
  @Override
  protected void setUp() throws Exception {

    super.setUp();

    final int tmpRowDim = Uniform.randomInteger(1, 9);
    final int tmpColDim = Uniform.randomInteger(1, 9);

    final BasicMatrix tmpBase = NonPhysicalTest.makeRandomMatrix(tmpRowDim, tmpColDim);
    final int tmpRowIndex = Uniform.randomInteger(tmpRowDim);
    final int tmpColumnIndex = Uniform.randomInteger(tmpColDim);
    final BigDecimal tmpElement = BigMath.PI;
    final MatrixStore<BigDecimal> aBase = BigDenseStore.FACTORY.copy((Access2D<?>) tmpBase);

    //        myBigStore = new
    // SuperimposedMatrixStore<BigDecimal>(BigDenseStore.FACTORY.copyMatrix(tmpBase), tmpRowIndex,
    // tmpColumnIndex, tmpElement);
    //        myComplexStore = new
    // SuperimposedMatrixStore<ComplexNumber>(ComplexDenseStore.FACTORY.copyMatrix(tmpBase),
    // tmpRowIndex, tmpColumnIndex, ComplexNumber.makeReal(tmpElement.doubleValue()));
    //        myPrimitiveStore = new
    // SuperimposedMatrixStore<Double>(PrimitiveDenseStore.FACTORY.copyMatrix(tmpBase), tmpRowIndex,
    // tmpColumnIndex, tmpElement.doubleValue());

    myBigStore =
        new SuperimposedStore<BigDecimal>(
            aBase,
            tmpRowIndex,
            tmpColumnIndex,
            new SingleStore<BigDecimal>(aBase.factory(), tmpElement));
    final MatrixStore<ComplexNumber> aBase1 = ComplexDenseStore.FACTORY.copy((Access2D<?>) tmpBase);
    myComplexStore =
        new SuperimposedStore<ComplexNumber>(
            aBase1,
            tmpRowIndex,
            tmpColumnIndex,
            new SingleStore<ComplexNumber>(
                aBase1.factory(), ComplexNumber.valueOf(tmpElement.doubleValue())));
    final MatrixStore<Double> aBase2 = PrimitiveDenseStore.FACTORY.copy((Access2D<?>) tmpBase);
    myPrimitiveStore =
        new SuperimposedStore<Double>(
            aBase2,
            tmpRowIndex,
            tmpColumnIndex,
            new SingleStore<Double>(aBase2.factory(), tmpElement.doubleValue()));
  }
예제 #4
0
 public void set(final Access1D<?> someCoefficient) {
   final int tmpLimit = (int) Math.min(this.size(), someCoefficient.count());
   for (int p = 0; p < tmpLimit; p++) {
     this.set(p, ComplexNumber.valueOf((Number) someCoefficient.get(p)));
   }
 }