Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Remove complex number classes/methods #6031

Merged
merged 8 commits into from Aug 1, 2018
Merged

Remove complex number classes/methods #6031

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
83f56f9
Complex cleanup, pt1
AlexDBlack Aug 1, 2018
b435e5b
Complex cleanup, pt2
AlexDBlack Aug 1, 2018
5a43125
Complex cleanup, pt3
AlexDBlack Aug 1, 2018
d0a8019
Complex cleanup, pt4
AlexDBlack Aug 1, 2018
3b51c00
Complex cleanup, pt5
AlexDBlack Aug 1, 2018
5f1f535
Complex cleanup, pt6 - nd4j compiles again, maybe?
AlexDBlack Aug 1, 2018
d506e5a
Small fix for VectorDeSerializer - no longer used/present field
AlexDBlack Aug 1, 2018
2884a6e
Small DL4J complex number changes given ND4J changes
AlexDBlack Aug 1, 2018
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
11 changes: 0 additions & 11 deletions .../deeplearning4j-core/src/test/java/org/deeplearning4j/optimize/solver/TestOptimizers.java
View file
Open in desktop
Expand Up @@ -40,7 +40,6 @@
import org.deeplearning4j.optimize.stepfunctions.NegativeDefaultStepFunction;
import org.junit.Test;
import org.nd4j.linalg.activations.Activation;
import org.nd4j.linalg.api.complex.IComplexNumber;
import org.nd4j.linalg.api.ndarray.INDArray;
import org.nd4j.linalg.api.ops.impl.transforms.Cos;
import org.nd4j.linalg.api.ops.impl.transforms.Sin;
Expand Down Expand Up @@ -520,11 +519,6 @@ public double epsThreshold() {
public Boolean apply(Number input) {
return Math.abs(input.doubleValue()) > 5.12;
}

@Override
public Boolean apply(IComplexNumber input) {
throw new UnsupportedOperationException();
}
});

int nExceeds512 = paramExceeds512.sum(Integer.MAX_VALUE).getInt(0);
Expand Down Expand Up @@ -723,11 +717,6 @@ public double epsThreshold() {
public Boolean apply(Number input) {
return Math.abs(input.doubleValue()) > 5.0;
}

@Override
public Boolean apply(IComplexNumber input) {
throw new UnsupportedOperationException();
}
});

int nExceeds5 = paramExceeds5.sum(Integer.MAX_VALUE).getInt(0);
Expand Down
1 change: 0 additions & 1 deletion ...-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/autodiff/samediff/SameDiff.java
View file
Open in desktop
Expand Up @@ -231,7 +231,6 @@ public static Cloner newCloner() {
//cloner.registerFastCloner(INDArray.class, new INDArrayFastCloner()); //Does not work due to interface
IFastCloner fc = new INDArrayFastCloner();
cloner.registerFastCloner(Nd4j.getBackend().getNDArrayClass(), fc);
cloner.registerFastCloner(Nd4j.getBackend().getComplexNDArrayClass(), fc);

//Same thing with DataBuffers: off heap -> cloner library chokes on them, but need to know the concrete
// buffer classes, not just the interface
Expand Down
6 changes: 0 additions & 6 deletions ...kends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/blas/BlasBufferUtil.java
View file
Open in desktop
Expand Up @@ -17,7 +17,6 @@
package org.nd4j.linalg.api.blas;

import org.nd4j.linalg.api.buffer.DataBuffer;
import org.nd4j.linalg.api.complex.IComplexNDArray;
import org.nd4j.linalg.api.ndarray.INDArray;
import org.nd4j.linalg.factory.NDArrayFactory;

Expand Down Expand Up @@ -46,9 +45,6 @@ public static int getBlasOffset(INDArray arr) {
* @return the blas stride
*/
public static int getBlasStride(INDArray arr) {
if (arr instanceof IComplexNDArray)
return arr.elementWiseStride() / 2;

return arr.elementWiseStride();
}

Expand Down Expand Up @@ -127,8 +123,6 @@ public static int getStrideForOrdering(INDArray arr) {
if (arr.ordering() == NDArrayFactory.FORTRAN) {
return getBlasStride(arr);
} else {
if (arr instanceof IComplexNDArray)
return arr.stride(1) / 2;
return arr.stride(1);
}
}
Expand Down
82 changes: 0 additions & 82 deletions ...nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/blas/Level1.java
View file
Open in desktop
Expand Up @@ -17,8 +17,6 @@
package org.nd4j.linalg.api.blas;

import org.nd4j.linalg.api.buffer.DataBuffer;
import org.nd4j.linalg.api.complex.IComplexNDArray;
import org.nd4j.linalg.api.complex.IComplexNumber;
import org.nd4j.linalg.api.ndarray.INDArray;

/**
Expand Down Expand Up @@ -54,30 +52,13 @@ public interface Level1 {
/** Vector-vector dot product */
double dot(long N, DataBuffer dx, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY);

/**
* computes a vector-vector dot product.
* @param n
* @param alpha
* @param X
* @param Y
* @return
*/
IComplexNumber dot(long N, IComplexNumber alpha, IComplexNDArray X, IComplexNDArray Y);

/**
* computes the Euclidean norm of a vector.
* @param arr
* @return
*/
double nrm2(INDArray arr);

/**
* computes the Euclidean norm of a vector.
* @param arr
* @return
*/
IComplexNumber nrm2(IComplexNDArray arr);

/**
* computes the sum of magnitudes of all vector elements or, for a complex vector x, the sum
* @param arr
Expand All @@ -88,14 +69,6 @@ public interface Level1 {
/** sum of magnitudes of all elements */
double asum(long N, DataBuffer x, int offsetX, int incrX);

/**
* computes the sum of magnitudes
* of all vector elements or, for a complex vector x, the sum
* @param arr
* @return
*/
IComplexNumber asum(IComplexNDArray arr);

/**
* finds the element of a
* vector that has the largest absolute value.
Expand All @@ -118,36 +91,20 @@ public interface Level1 {
/** Index of largest absolute value */
int iamax(long N, DataBuffer x, int offsetX, int incrX);

/**
* finds the element of a vector that has the largest absolute value.
* @param arr
* @return
*/
int iamax(IComplexNDArray arr);

/**
* finds the element of a vector that has the minimum absolute value.
* @param arr
* @return
*/
int iamin(INDArray arr);

/**
* finds the element of a vector that has the minimum absolute value.
* @param arr
* @return
*/
int iamin(IComplexNDArray arr);

/**
* swaps a vector with another vector.
* @param x
* @param y
*/
void swap(INDArray x, INDArray y);

void swap(IComplexNDArray x, IComplexNDArray y);

/**
* copy a vector to another vector.
* @param x
Expand All @@ -161,8 +118,6 @@ public interface Level1 {
*/
void copy(long N, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY);

void copy(IComplexNDArray x, IComplexNDArray y);

/**
* computes a vector-scalar product and adds the result to a vector.
* @param n
Expand All @@ -186,15 +141,6 @@ public interface Level1 {
*/
void axpy(long N, double alpha, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY);

/**
* computes a vector-scalar product and adds the result to a vector.
* @param n
* @param alpha
* @param x
* @param y
*/
void axpy(long N, IComplexNumber alpha, IComplexNDArray x, IComplexNDArray y);

/**
* computes parameters for a Givens rotation.
* @param a
Expand All @@ -214,16 +160,6 @@ public interface Level1 {
*/
void rot(long N, INDArray X, INDArray Y, double c, double s);

/**
* performs rotation of points in the plane.
* @param N
* @param X
* @param Y
* @param c
* @param s
*/
void rot(long N, IComplexNDArray X, IComplexNDArray Y, IComplexNumber c, IComplexNumber s);

/**
* computes the modified parameters for a Givens rotation.
* @param d1
Expand All @@ -234,16 +170,6 @@ public interface Level1 {
*/
void rotmg(INDArray d1, INDArray d2, INDArray b1, double b2, INDArray P);

/**
* computes the modified parameters for a Givens rotation.
* @param d1
* @param d2
* @param b1
* @param b2
* @param P
*/
void rotmg(IComplexNDArray d1, IComplexNDArray d2, IComplexNDArray b1, IComplexNumber b2, IComplexNDArray P);

/**
* computes a vector by a scalar product.
* @param N
Expand All @@ -252,14 +178,6 @@ public interface Level1 {
*/
void scal(long N, double alpha, INDArray X);

/**
* computes a vector by a scalar product.
* @param N
* @param alpha
* @param X
*/
void scal(long N, IComplexNumber alpha, IComplexNDArray X);


/** Can we use the axpy and copy methods that take a DataBuffer instead of an INDArray with this backend? */
boolean supportsDataBufferL1Ops();
Expand Down
120 changes: 0 additions & 120 deletions ...nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/blas/Level2.java
View file
Open in desktop
Expand Up @@ -16,8 +16,6 @@

package org.nd4j.linalg.api.blas;

import org.nd4j.linalg.api.complex.IComplexNDArray;
import org.nd4j.linalg.api.complex.IComplexNumber;
import org.nd4j.linalg.api.ndarray.INDArray;

/**
Expand Down Expand Up @@ -56,23 +54,6 @@ public interface Level2 {
*/
void gemv(char order, char transA, double alpha, INDArray A, INDArray X, double beta, INDArray Y);

/**
* gemv computes a matrix-vector product using a general matrix and performs one of the following matrix-vector operations:
y := alpha*a*x + beta*y for trans = 'N'or'n';
y := alpha*a'*x + beta*y for trans = 'T'or't';
y := alpha*conjg(a')*x + beta*y for trans = 'C'or'c'.
Here a is an m-by-n band matrix, x and y are vectors, alpha and beta are scalars.
* @param order
* @param transA
* @param alpha
* @param A
* @param X
* @param beta
* @param Y
*/
void gemv(char order, char transA, IComplexNumber alpha, IComplexNDArray A, IComplexNDArray X, IComplexNumber beta,
IComplexNDArray Y);

/**
* gbmv computes a matrix-vector product using a general band matrix and performs one of the following matrix-vector operations:
y := alpha*a*x + beta*y for trans = 'N'or'n';
Expand All @@ -91,25 +72,6 @@ void gemv(char order, char transA, IComplexNumber alpha, IComplexNDArray A, ICom
*/
void gbmv(char order, char TransA, int KL, int KU, double alpha, INDArray A, INDArray X, double beta, INDArray Y);

/**
* gbmv computes a matrix-vector product using a general band matrix and performs one of the following matrix-vector operations:
y := alpha*a*x + beta*y for trans = 'N'or'n';
y := alpha*a'*x + beta*y for trans = 'T'or't';
y := alpha*conjg(a')*x + beta*y for trans = 'C'or'c'.
Here a is an m-by-n band matrix with ku superdiagonals and kl subdiagonals, x and y are vectors, alpha and beta are scalars.
* @param order
* @param TransA
* @param KL
* @param KU
* @param alpha
* @param A
* @param X
* @param beta
* @param Y
*/
void gbmv(char order, char TransA, int KL, int KU, IComplexNumber alpha, IComplexNDArray A, IComplexNDArray X,
IComplexNumber beta, IComplexNDArray Y);


/**
* performs a rank-1 update of a general m-by-n matrix a:
Expand All @@ -122,88 +84,6 @@ void gbmv(char order, char TransA, int KL, int KU, IComplexNumber alpha, IComple
*/
void ger(char order, double alpha, INDArray X, INDArray Y, INDArray A);



/**
* performs a rank-1 update of a general m-by-n matrix a, without conjugation:
a := alpha*x*y' + a.
* @param order
* @param alpha
* @param X
* @param Y
* @param A
*/
void geru(char order, IComplexNumber alpha, IComplexNDArray X, IComplexNDArray Y, IComplexNDArray A);



/**
* performs a rank-1 update of a general m-by-n matrix a, without conjugation:
a := alpha*x*y' + a.
* @param order
* @param alpha
* @param X
* @param Y
* @param A
*/
void hbmv(char order, char Uplo, IComplexNumber alpha, IComplexNDArray A, IComplexNDArray X, IComplexNumber beta,
IComplexNDArray Y);

/**
* hemv computes a matrix-vector product using a Hermitian matrix:
y := alpha*a*x + beta*y.
Here a is an n-by-n Hermitian band matrix with k superdiagonals, x and y are n-element vectors, alpha and beta are scalars.
* @param order
* @param Uplo
* @param alpha
* @param A
* @param X
* @param beta
* @param Y
*/
void hemv(char order, char Uplo, IComplexNumber alpha, IComplexNDArray A, IComplexNDArray X, IComplexNumber beta,
IComplexNDArray Y);

/**
* ?her2 performs a rank-2 update of an n-by-n Hermitian matrix a:
a := alpha*x*conjg(y') + conjg(alpha)*y*conjg(x') + a.
* @param order
* @param Uplo
* @param alpha
* @param X
* @param Y
* @param A
*/
void her2(char order, char Uplo, IComplexNumber alpha, IComplexNDArray X, IComplexNDArray Y, IComplexNDArray A);

/**
* ?hpmv computes a matrix-vector product using a Hermitian packed matrix:
y := alpha*a*x + beta*y.
Here a is an n-by-n packed Hermitian matrix, x and y are n-element vectors, alpha and beta are scalars.
* @param order
* @param Uplo
* @param N
* @param alpha
* @param Ap
* @param X
* @param beta
* @param Y
*/
void hpmv(char order, char Uplo, int N, IComplexNumber alpha, IComplexNDArray Ap, IComplexNDArray X,
IComplexNumber beta, IComplexNDArray Y);

/**
* hpr2 performs a rank-2 update of an n-by-n packed Hermitian matrix a:
a := alpha*x*conjg(y') + conjg(alpha)*y*conjg(x') + a.
* @param order
* @param Uplo
* @param alpha
* @param X
* @param Y
* @param Ap
*/
void hpr2(char order, char Uplo, IComplexNumber alpha, IComplexNDArray X, IComplexNDArray Y, IComplexNDArray Ap);

/**
* sbmv computes a matrix-vector product using a symmetric band matrix:
y := alpha*a*x + beta*y.
Expand Down