Esempio n. 1
0
 @Override
 public IComplexNumber exp() {
   IComplexNumber result = dup();
   double realExp = FastMath.exp(realComponent());
   return result.set(
       realExp * FastMath.cos(imaginaryComponent()), realExp * FastMath.sin(imaginaryComponent()));
 }
Esempio n. 2
0
 @Override
 public IComplexNumber powi(IComplexNumber c, IComplexNumber result) {
   IComplexNumber eval = log().muli(c).exp();
   result.set(eval.realComponent(), eval.imaginaryComponent());
   result.set(eval.realComponent(), eval.imaginaryComponent());
   return result;
 }
  @Test
  public void testComplexCalculation() {
    IComplexNDArray arr =
        Nd4j.createComplex(
            new IComplexNumber[][] {
              {Nd4j.createComplexNumber(1, 1), Nd4j.createComplexNumber(2, 1)},
              {Nd4j.createComplexNumber(3, 2), Nd4j.createComplexNumber(4, 2)}
            });

    IComplexNumber scalar = arr.sumComplex();
    double sum = scalar.realComponent().doubleValue();
    assertEquals(10, sum, 1e-1);

    double sumImag = scalar.imaginaryComponent().doubleValue();
    assertEquals(6, sumImag, 1e-1);

    IComplexNDArray res = arr.add(Nd4j.createComplexNumber(1, 1));
    scalar = res.sumComplex();
    sum = scalar.realComponent().doubleValue();
    assertEquals(14, sum, 1e-1);
    sumImag = scalar.imaginaryComponent().doubleValue();
    assertEquals(10, sumImag, 1e-1);

    // original array should keep as it is
    sum = arr.sumComplex().realComponent().doubleValue();
    assertEquals(10, sum, 1e-1);
  }
Esempio n. 4
0
 /**
  * Multiply two complex numbers, inplace
  *
  * @param c
  * @param result
  */
 @Override
 public IComplexNumber muli(IComplexNumber c, IComplexNumber result) {
   float newR =
       real() * c.realComponent().floatValue() - imag() * c.imaginaryComponent().floatValue();
   float newI =
       real() * c.imaginaryComponent().floatValue() + imag() * c.realComponent().floatValue();
   result.set(newR, newI);
   return result;
 }
Esempio n. 5
0
 @Override
 public IComplexNumber log() {
   IComplexNumber result = dup();
   float real = (float) result.realComponent();
   float imaginary = (float) result.imaginaryComponent();
   double modulus = FastMath.sqrt(real * real + imaginary * imaginary);
   double arg = FastMath.atan2(imaginary, real);
   return result.set(FastMath.log(modulus), arg);
 }
Esempio n. 6
0
 @Override
 public IComplexNumber divi(Number v, IComplexNumber result) {
   if (this == result) {
     set(real() / v.doubleValue(), imag());
   } else {
     result.set(result.realComponent().doubleValue() / v.doubleValue(), imaginaryComponent());
   }
   return result;
 }
Esempio n. 7
0
 /**
  * Multiply two complex numbers, inplace
  *
  * @param c
  * @param result
  */
 @Override
 public IComplexNumber muli(IComplexNumber c, IComplexNumber result) {
   double newR =
       (real() * c.realComponent().doubleValue() - imag() * c.imaginaryComponent().doubleValue());
   double newI =
       (real() * c.imaginaryComponent().doubleValue() + imag() * c.realComponent().doubleValue());
   result.set(newR, newI);
   return result;
 }
Esempio n. 8
0
 @Override
 public IComplexNumber lt(IComplexNumber num) {
   double val = num.realComponent().doubleValue();
   double imag = num.imaginaryComponent().doubleValue();
   double otherVal = num.realComponent().doubleValue();
   double otherImag = num.imaginaryComponent().doubleValue();
   if (val < otherVal) return Nd4j.createComplexNumber(1, 0);
   else if (val > otherVal) return Nd4j.createComplexNumber(0, 0);
   else if (imag < otherImag) return Nd4j.createComplexNumber(1, 0);
   else return Nd4j.createComplexNumber(0, 0);
 }
Esempio n. 9
0
 /**
  * Comparing two floatComplex values.
  *
  * @param o
  */
 @Override
 public boolean equals(Object o) {
   if (!(o instanceof IComplexNumber)
       || !(o instanceof org.jblas.ComplexFloat) && !(o instanceof org.jblas.ComplexDouble)) {
     return false;
   } else {
     if (o instanceof org.jblas.ComplexFloat) return super.equals(o);
     else {
       IComplexNumber num = (IComplexNumber) o;
       return num.realComponent().doubleValue() == realComponent().doubleValue()
           && num.imaginaryComponent().doubleValue() == imaginaryComponent().doubleValue();
     }
   }
 }
 @Test
 public void testCreateComplexFromReal() {
   INDArray n = Nd4j.create(new double[] {1, 2, 3, 4, 5, 6, 7, 8}, new int[] {2, 4});
   IComplexNDArray nComplex = Nd4j.createComplex(n);
   for (int i = 0; i < n.vectorsAlongDimension(0); i++) {
     INDArray vec = n.vectorAlongDimension(i, 0);
     IComplexNDArray vecComplex = nComplex.vectorAlongDimension(i, 0);
     assertEquals(vec.length(), vecComplex.length());
     for (int j = 0; j < vec.length(); j++) {
       IComplexNumber currComplex = vecComplex.getComplex(j);
       double curr = vec.getFloat(j);
       assertEquals(curr, currComplex.realComponent().doubleValue(), 1e-1);
     }
     assertEquals(vec, vecComplex.getReal());
   }
 }
Esempio n. 11
0
 private static IComplexNumber sigmoidDeriv(IComplexNumber number) {
   double arg = number.complexArgument().doubleValue();
   double sigArg = 1 / 1 + (FastMath.exp(-arg)) - 1 + .5f;
   double ret = Math.exp(sigArg);
   IComplexDouble sigmoid = Nd4j.createDouble(ret, 0);
   IComplexNumber oneMinus = Nd4j.createComplexNumber(1, 1).subi(sigmoid);
   return sigmoid.mul(oneMinus);
 }
Esempio n. 12
0
  /**
   * Comparing two floatComplex values.
   *
   * @param o
   */
  @Override
  public boolean equals(Object o) {
    if (!(o instanceof IComplexNumber)
        || !(o instanceof org.jblas.ComplexFloat) && !(o instanceof org.jblas.ComplexDouble)) {
      return false;
    } else {

      IComplexNumber num = (IComplexNumber) o;
      double thisReal = realComponent().doubleValue();
      double otherReal = num.realComponent().doubleValue();
      double thisImag = imaginaryComponent().doubleValue();
      double otherImag = imaginaryComponent().doubleValue();
      double diff = Math.abs(thisReal - otherReal);
      double imagDiff = Math.abs(thisImag - otherImag);
      return diff < Nd4j.EPS_THRESHOLD && imagDiff < Nd4j.EPS_THRESHOLD;
    }
  }
  @Test
  public void testBasicOperations() {
    IComplexNDArray arr =
        Nd4j.createComplex(new double[] {0, 1, 2, 1, 1, 2, 3, 4}, new int[] {2, 2});
    IComplexNumber scalar = arr.sumComplex();
    double sum = scalar.realComponent().doubleValue();
    assertEquals(6, sum, 1e-1);
    arr.addi(1);
    scalar = arr.sumComplex();
    sum = scalar.realComponent().doubleValue();
    assertEquals(10, sum, 1e-1);
    arr.subi(Nd4j.createDouble(1, 0));
    scalar = arr.sumComplex();

    sum = scalar.realComponent().doubleValue();
    assertEquals(6, sum, 1e-1);
  }
Esempio n. 14
0
 /**
  * Divide two complex numbers, in-place
  *
  * @param c
  * @param result
  */
 @Override
 public IComplexNumber divi(IComplexNumber c, IComplexNumber result) {
   float d =
       c.realComponent().floatValue() * c.realComponent().floatValue()
           + c.imaginaryComponent().floatValue() * c.imaginaryComponent().floatValue();
   float newR =
       (real() * c.realComponent().floatValue() + imag() * c.imaginaryComponent().floatValue())
           / d;
   float newI =
       (imag() * c.realComponent().floatValue() - real() * c.imaginaryComponent().floatValue())
           / d;
   result.set(newR, newI);
   return result;
 }
Esempio n. 15
0
 private void setMax(Object[] extraArgs) {
   if (extraArgs.length < 1) throw new IllegalArgumentException("Please specify a max value");
   if (Double.isNaN(max.doubleValue()) && extraArgs[0] instanceof Number) {
     max = Double.valueOf(extraArgs[0].toString());
   } else if (Double.isNaN(maxComplex.realComponent().doubleValue())
       && extraArgs[0] instanceof IComplexNumber) {
     maxComplex = (IComplexNumber) extraArgs[0];
   }
 }
Esempio n. 16
0
 @Override
 public IComplexNumber rdivi(Number v, IComplexNumber result) {
   float d =
       result.realComponent().floatValue() * result.realComponent().floatValue()
           + result.imaginaryComponent().floatValue() * result.imaginaryComponent().floatValue();
   return result.set(
       v.floatValue() * result.realComponent().floatValue() / d,
       -v.floatValue() * result.imaginaryComponent().floatValue() / d);
 }
  @Test
  public void testMatrixGet() {

    IComplexNDArray arr = Nd4j.createComplex((Nd4j.linspace(1, 4, 4))).reshape(2, 2);
    IComplexNumber n1 = arr.getComplex(0, 0);
    IComplexNumber n2 = arr.getComplex(0, 1);
    IComplexNumber n3 = arr.getComplex(1, 0);
    IComplexNumber n4 = arr.getComplex(1, 1);

    assertEquals(1, n1.realComponent().doubleValue(), 1e-1);
    assertEquals(3, n2.realComponent().doubleValue(), 1e-1);
    assertEquals(2, n3.realComponent().doubleValue(), 1e-1);
    assertEquals(4, n4.realComponent().doubleValue(), 1e-1);
  }
Esempio n. 18
0
  @Override
  public void put(int i, IComplexNumber result) {

    modified.set(true);
    if (dataType() == DataBuffer.Type.FLOAT) {
      JCublas2.cublasSetVector(
          (int) length(),
          getElementSize(),
          PointerUtil.getPointer(CudaComplexConversion.toComplex(result.asFloat())),
          1,
          getHostPointer(),
          1);
    } else {
      JCublas2.cublasSetVector(
          (int) length(),
          getElementSize(),
          PointerUtil.getPointer(CudaComplexConversion.toComplexDouble(result.asDouble())),
          1,
          getHostPointer(),
          1);
    }
  }
Esempio n. 19
0
 /**
  * Subtract two complex numbers, in-place
  *
  * @param c
  * @param result
  */
 @Override
 public IComplexNumber subi(IComplexNumber c, IComplexNumber result) {
   if (this == result) {
     set(real() - c.realComponent().doubleValue(), imag() - c.imaginaryComponent().doubleValue());
   } else {
     result.set(
         result.realComponent().doubleValue() - c.realComponent().doubleValue(),
         result.imaginaryComponent().doubleValue() - c.imaginaryComponent().doubleValue());
   }
   return this;
 }
  @Test
  public void testPutAndGet() {
    IComplexNDArray multiRow = Nd4j.createComplex(2, 2);
    multiRow.putScalar(0, 0, Nd4j.createComplexNumber(1, 0));
    multiRow.putScalar(0, 1, Nd4j.createComplexNumber(2, 0));
    multiRow.putScalar(1, 0, Nd4j.createComplexNumber(3, 0));
    multiRow.putScalar(1, 1, Nd4j.createComplexNumber(4, 0));
    assertEquals(Nd4j.createComplexNumber(1, 0), multiRow.getComplex(0, 0));
    assertEquals(Nd4j.createComplexNumber(2, 0), multiRow.getComplex(0, 1));
    assertEquals(Nd4j.createComplexNumber(3, 0), multiRow.getComplex(1, 0));
    assertEquals(Nd4j.createComplexNumber(4, 0), multiRow.getComplex(1, 1));

    IComplexNDArray arr =
        Nd4j.createComplex(Nd4j.create(new double[] {1, 2, 3, 4}, new int[] {2, 2}));
    assertEquals(4, arr.length());
    assertEquals(8, arr.data().length());
    arr.put(1, 1, Nd4j.scalar(5.0));

    IComplexNumber n1 = arr.getComplex(1, 1);
    IComplexNumber n2 = arr.getComplex(1, 1);

    assertEquals(getFailureMessage(), 5.0, n1.realComponent().doubleValue(), 1e-1);
    assertEquals(getFailureMessage(), 0.0, n2.imaginaryComponent().doubleValue(), 1e-1);
  }
Esempio n. 21
0
 protected void verifyElements(IComplexNDArray d, IComplexNDArray d2) {
   for (int i = 0; i < d.rows(); i++) {
     for (int j = 0; j < d.columns(); j++) {
       IComplexNumber test1 = d.getComplex(i, j);
       IComplexNumber test2 = d2.getComplex(i, j);
       assertEquals(
           test1.realComponent().doubleValue(), test2.realComponent().doubleValue(), 1e-6);
       assertEquals(
           test1.imaginaryComponent().doubleValue(),
           test2.imaginaryComponent().doubleValue(),
           1e-6);
     }
   }
 }
Esempio n. 22
0
 @Override
 public IComplexNumber op(IComplexNumber origin, IComplexNumber other) {
   if (complexNumber != null) return origin.sub(complexNumber);
   return complexNumber.sub(num);
 }
Esempio n. 23
0
 @Override
 public IComplexNumber rdivi(Number v, IComplexNumber result) {
   return result.set(v.doubleValue() / real(), imaginaryComponent());
 }
Esempio n. 24
0
 @Override
 public IComplexNumber rdivi(IComplexNumber c, IComplexNumber result) {
   return result.set(c.div(this));
 }
Esempio n. 25
0
 @Override
 public IComplexNumber set(IComplexNumber set) {
   return (IComplexNumber)
       set(set.realComponent().doubleValue(), set.imaginaryComponent().doubleValue());
 }
Esempio n. 26
0
 @Override
 public IComplexNumber rsubi(IComplexNumber a, IComplexNumber result) {
   return result.set(a.sub(this));
 }
Esempio n. 27
0
 @Override
 public IComplexNumber rsubi(Number a, IComplexNumber result) {
   return result.set(a.doubleValue() - realComponent().doubleValue(), imaginaryComponent());
 }
Esempio n. 28
0
 @Override
 public IComplexNumber copy(IComplexNumber other) {
   return other.set(this);
 }
Esempio n. 29
0
 @Override
 public void put(long i, IComplexNumber result) {
   put(i, result.realComponent().doubleValue());
   put(i + 1, result.imaginaryComponent().doubleValue());
 }
Esempio n. 30
0
 @Override
 public IComplexNumber getAndSetFinalResult(IComplexNumber accum) {
   finalResultComplex = accum.div(n());
   return finalResultComplex;
 }