fix compiler warnings in nd4j examples.

Signed-off-by: Robert Altena <[email protected]>

Author: RobAltena

nd4j-examples/src/main/java/org/nd4j/examples/ConcatVstackHstackPad.java

@@ -1,4 +1,4 @@
-/*******************************************************************************
+/* *****************************************************************************
  * Copyright (c) 2015-2019 Skymind, Inc.
  *
  * This program and the accompanying materials are made available under the
@@ -80,9 +80,6 @@ public static void main(String[] args) {
         INDArray vstack = Nd4j.vstack(ones,zeros);
         System.out.println("### VSTACK ####");
         System.out.println(vstack);
-
-
-
     }
 
 }

nd4j-examples/src/main/java/org/nd4j/examples/CustomOpsExamples.java

@@ -1,4 +1,4 @@
-/*******************************************************************************
+/* *****************************************************************************
  * Copyright (c) 2015-2019 Skymind, Inc.
  *
  * This program and the accompanying materials are made available under the
@@ -65,7 +65,5 @@ public static void main(String[] args){
         Nd4j.getExecutioner().exec(op);
 
         System.out.println(output1 + "\n\n" + output2);
-
     }
-
 }

nd4j-examples/src/main/java/org/nd4j/examples/Nd4jEx10_ElementWiseOperation.java

@@ -1,4 +1,4 @@
-/*******************************************************************************
+/* *****************************************************************************
  * Copyright (c) 2015-2019 Skymind, Inc.
  *
  * This program and the accompanying materials are made available under the
@@ -16,7 +16,6 @@
 
 package org.nd4j.examples;
 
-import org.nd4j.linalg.api.buffer.DataBuffer;
 import org.nd4j.linalg.api.ndarray.INDArray;
 import org.nd4j.linalg.factory.Nd4j;
 
@@ -27,13 +26,10 @@
  *
  * Created by cvn on 9/6/14.
  */
-
-
 public class Nd4jEx10_ElementWiseOperation {
 
     public static void main(String[] args) {
-        //Nd4j.dtype = DataBuffer.DOUBLE;
-        INDArray nd1 = Nd4j.create(new double[]{1,2,3,4,5,6},new int[]{2,3});
+        INDArray nd1 = Nd4j.create(new double[]{1,2,3,4,5,6}, 2,3);
         System.out.println("nd1:\n"+nd1);
 
         //create nd-array variable ndv to be able to print result of nondestructive operations. add scalar to matrix and assign ndv the sum.
@@ -53,7 +49,7 @@ public static void main(String[] args) {
 
         //add column vector to matrix
 
-        INDArray nd2 = Nd4j.create(new double[]{10,20},new int[]{2,1}); //vector as column
+        INDArray nd2 = Nd4j.create(new double[]{10,20}, 2,1); //vector as column
         System.out.println("nd2:\n"+nd2);
 
         ndv = nd1.addColumnVector(nd2);
@@ -62,7 +58,7 @@ public static void main(String[] args) {
 
         // add row vector to matrix
 
-        INDArray nd3 = Nd4j.create(new double[]{30,40,50},new int[]{1, 3}); //vector as row
+        INDArray nd3 = Nd4j.create(new double[]{30,40,50}, 1, 3); //vector as row
         System.out.println("nd3:\n"+nd3);
 
         ndv = nd1.addRowVector(nd3);
@@ -71,14 +67,11 @@ public static void main(String[] args) {
 
         //multiply two matrices of equal dimensions elementwise.
 
-        INDArray nd4 = Nd4j.create(new double[]{1,2,1,2,1,2},new int[]{2,3});
+        INDArray nd4 = Nd4j.create(new double[]{1,2,1,2,1,2}, 2,3);
         System.out.println("nd4:\n"+nd4);
 
         ndv = nd1.mul(nd4);
 
         System.out.println("nd1.mul(nd4):\n"+ndv);
-
-
     }
-
 }

nd4j-examples/src/main/java/org/nd4j/examples/Nd4jEx11_Axpy.java

@@ -1,4 +1,4 @@
-/*******************************************************************************
+/* *****************************************************************************
  * Copyright (c) 2015-2019 Skymind, Inc.
  *
  * This program and the accompanying materials are made available under the
@@ -16,7 +16,6 @@
 
 package org.nd4j.examples;
 
-import org.nd4j.linalg.api.buffer.DataBuffer;
 import org.nd4j.linalg.api.buffer.DataType;
 import org.nd4j.linalg.api.ndarray.INDArray;
 import org.nd4j.linalg.factory.Nd4j;

nd4j-examples/src/main/java/org/nd4j/examples/Nd4jEx12_INDArrayFromCSCMatrix.java

@@ -1,4 +1,4 @@
-/*******************************************************************************
+/* *****************************************************************************
  * Copyright (c) 2015-2019 Skymind, Inc.
  *
  * This program and the accompanying materials are made available under the
@@ -26,7 +26,6 @@
  *
  * @author Audrey Loeffel
  */
-
 public class Nd4jEx12_INDArrayFromCSCMatrix {
 
     public static void main(String[] args) {
@@ -36,33 +35,29 @@ public static void main(String[] args) {
         int[] columnPointers = {0, 1, 3, 5};
         double[] dataCSC = {11, 12, 22, 13, 23, 14, 34};
         int[] shapeCSC = {5, 4};
-        INDArray matrix = createFromCSC(dataCSC, rowIndices, columnPointers, shapeCSC);
-        System.out.println("nd array is: \n" + matrix);
-        long[] matrixCSCShape = matrix.shape();
-        System.out.println("Its shape is [" + matrixCSCShape[0] +","+ matrixCSCShape[1]+"]");
+        createFromCSC(dataCSC, rowIndices, columnPointers, shapeCSC);
 
         System.out.println("-------- CSC with empty column to INDArray -------");
         int[] rowIndices2 = {1, 2};
         int[] columnPointers2 = {0, 0, 1};
         double[] dataCSC2 = {22, 33};
         int[] shapeCSC2 = {4, 3};
-        INDArray matrix2 = createFromCSC(dataCSC2, rowIndices2, columnPointers2, shapeCSC2);
-        System.out.println("nd array is: \n" + matrix2);
-        long[] matrixCSCShape2 = matrix2.shape();
-        System.out.println("Its shape is [" + matrixCSCShape2[0] +","+ matrixCSCShape2[1]+"]");
+        createFromCSC(dataCSC2, rowIndices2, columnPointers2, shapeCSC2);
     }
 
-    private static INDArray createFromCSC(double[] data, int[] rowIndices, int[] columnPointers, int[] shape){
+    private static void createFromCSC(double[] data, int[] rowIndices, int[] columnPointers, int[] shape){
         INDArray result = Nd4j.zeros(shape);
         int columns = shape[1];
         int dataIdx = 0;
         for(int i = 0; i < columns; i++){
             for(int k = dataIdx; k < (i == columnPointers.length-1 ? rowIndices.length : columnPointers[i+1]); k++, dataIdx++){
                 int j = rowIndices[k];
                 result.put(j, i, data[k]);
-                //System.out.println("i = "+i+", k = "+k+ ", data[k] = "+data[k]+"\n matrix = "+result.toString());
             }
         }
-        return result;
+        // Normally one would return the result. For this example we just print the result.
+        System.out.println("nd array is: \n" + result);
+        long[] matrixCSCShape2 = result.shape();
+        System.out.println("Its shape is [" + matrixCSCShape2[0] +","+ matrixCSCShape2[1]+"]");
     }
 }

nd4j-examples/src/main/java/org/nd4j/examples/Nd4jEx13_LargeMatrices.java

@@ -1,4 +1,4 @@
-/*******************************************************************************
+/* *****************************************************************************
  * Copyright (c) 2015-2019 Skymind, Inc.
  *
  * This program and the accompanying materials are made available under the
@@ -18,8 +18,6 @@
 
 import org.nd4j.linalg.api.ndarray.INDArray;
 import org.nd4j.linalg.factory.Nd4j;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /**
  * --- Nd4j Example 13: Large Matrix ---
@@ -28,15 +26,10 @@
  *
  * @author Adam Gibson
  */
-
 public class Nd4jEx13_LargeMatrices {
 
-    private static Logger log = LoggerFactory.getLogger(Nd4jEx13_LargeMatrices.class);
-
     public static void main(String[] args) {
-        INDArray n = Nd4j.linspace(1,10000000,10000000);
+        INDArray n = Nd4j.linspace(1,10000000,10000000).reshape(1, 10000000);
         System.out.println("MMUL" + n.mmul(n.transpose()));
-
     }
-
 }

nd4j-examples/src/main/java/org/nd4j/examples/Nd4jEx14_Normalizers.java

@@ -1,4 +1,4 @@
-/*******************************************************************************
+/* *****************************************************************************
  * Copyright (c) 2015-2019 Skymind, Inc.
  *
  * This program and the accompanying materials are made available under the

nd4j-examples/src/main/java/org/nd4j/examples/Nd4jEx15_Workspaces.java

@@ -1,4 +1,4 @@
-/*******************************************************************************
+/* *****************************************************************************
  * Copyright (c) 2015-2019 Skymind, Inc.
  *
  * This program and the accompanying materials are made available under the
@@ -38,24 +38,24 @@
  *
  * @author [email protected]
  */
+@SuppressWarnings("unused") //variable names clarify the example.
 public class Nd4jEx15_Workspaces {
     private static final Logger log = org.slf4j.LoggerFactory.getLogger(Nd4jEx15_Workspaces.class);
 
-    public static void main(String[] args) throws Exception {
-        /**
+    public static void main(String[] args) {
+        /*
          * Each workspace is tied to a JVM Thread via ID. So, same ID in different threads will point to different actual workspaces
          * Each workspace is created using some configuration, and different workspaces can either share the same config, or have their own
          */
 
-        // we create config with 10MB memory space preallocated
+        // we create config with 10MB memory space pre allocated
         WorkspaceConfiguration initialConfig = WorkspaceConfiguration.builder()
             .initialSize(10 * 1024L * 1024L)
             .policyAllocation(AllocationPolicy.STRICT)
             .policyLearning(LearningPolicy.NONE)
             .build();
 
-
-        INDArray result = null;
+        INDArray result;
 
         // we use
         try(MemoryWorkspace ws = Nd4j.getWorkspaceManager().getAndActivateWorkspace(initialConfig, "SOME_ID")) {
@@ -68,22 +68,19 @@ public static void main(String[] args) throws Exception {
             // please note, new array mean will be also attached to this workspace
             INDArray mean = array.mean(1);
 
-            /**
+            /*
              * PLEASE NOTE: if after doing some operations on the workspace, you want to bring result away from it, you should either leverage it, or detach
              */
-
             result = mean.detach();
         }
 
         // Since we've detached array, we expect FALSE printed out here. So, result array is managed by GC now.
         log.info("Array attached? {}", result.isAttached());
 
 
-
-        /**
+        /*
          * Workspace can be initially preallocated as shown above, or can be learning their desired size over time, or after first loop
          */
-
         WorkspaceConfiguration learningConfig = WorkspaceConfiguration.builder()
             .policyAllocation(AllocationPolicy.STRICT) // <-- this option disables overallocation behavior
             .policyLearning(LearningPolicy.FIRST_LOOP) // <-- this option makes workspace learning after first loop
@@ -93,7 +90,7 @@ public static void main(String[] args) throws Exception {
             try (MemoryWorkspace ws = Nd4j.getWorkspaceManager().getAndActivateWorkspace(learningConfig, "OTHER_ID")) {
                 INDArray array = Nd4j.create(100);
 
-                /**
+                /*
                  * At first iteration, workspace will be spilling all allocations as separate memory chunks.
                  * But after first iteration is finished - workspace will be allocated, to match all required allocations in this loop
                  * So, further iterations will be reusing workspace memory over and over again
@@ -102,7 +99,7 @@ public static void main(String[] args) throws Exception {
         }
 
 
-        /**
+        /*
          * Workspaces can be nested. And INDArrays can migrate between them, if needed
          */
 
@@ -123,7 +120,7 @@ public static void main(String[] args) throws Exception {
         }
 
 
-        /**
+        /*
          * You can break your workspace flow, if, for some reason you need part of calculations to be handled with GC
          */
         try(MemoryWorkspace ws1 = Nd4j.getWorkspaceManager().getAndActivateWorkspace(initialConfig, "SOME_ID")) {
@@ -132,17 +129,14 @@ public static void main(String[] args) throws Exception {
 
             try(MemoryWorkspace ws = Nd4j.getWorkspaceManager().scopeOutOfWorkspaces()) {
                 // anything allocated within this try block will be managed by GC
-
                 array2 = Nd4j.create(10, 10).assign(2.0f);
             }
 
-
             // at this point sumRes contains valid data, allocated in current workspace. We expect 300 printed here.
             log.info("Sum: {}", array1.addi(array2).sumNumber().floatValue());
         }
 
-
-        /**
+        /*
          * It's also possible to build workspace that'll be acting as circular buffer.
          */
         WorkspaceConfiguration circularConfig = WorkspaceConfiguration.builder()
@@ -153,7 +147,7 @@ public static void main(String[] args) throws Exception {
             .build();
 
         for (int x = 0; x < 10; x++) {
-            // since this workspace is ciruclar, we know that all pointers allocated before buffer ended - will be viable.
+            // since this workspace is circular, we know that all pointers allocated before buffer ended - will be viable.
             try (MemoryWorkspace ws1 = Nd4j.getWorkspaceManager().getAndActivateWorkspace(circularConfig, "CIRCULAR_ID")) {
                 INDArray array = Nd4j.create(100);
                 // so, you can use this array anywhere as long as YOU're sure buffer wasn't reset.

nd4j-examples/src/main/java/org/nd4j/examples/Nd4jEx1_INDArrayBasics.java

@@ -1,4 +1,4 @@
-/*******************************************************************************
+/* *****************************************************************************
  * Copyright (c) 2015-2019 Skymind, Inc.
  *
  * This program and the accompanying materials are made available under the
@@ -64,7 +64,7 @@ public static void main(String[] args) {
         System.out.println("Is a vector:        " + myArray.isVector());
         System.out.println("Is a scalar:        " + myArray.isScalar());
         System.out.println("Is a matrix:        " + myArray.isMatrix());
-        System.out.println("Is a square matrix: " + myArray.isSquare());;
+        System.out.println("Is a square matrix: " + myArray.isSquare());
 
 
 

nd4j-examples/src/main/java/org/nd4j/examples/Nd4jEx2_CreatingINDArrays.java

@@ -1,4 +1,4 @@
-/*******************************************************************************
+/* *****************************************************************************
  * Copyright (c) 2015-2019 Skymind, Inc.
  *
  * This program and the accompanying materials are made available under the
@@ -55,7 +55,7 @@ public static void main(String[] args){
         System.out.println("rowVector:              " + rowVector);
         System.out.println("rowVector.shape():      " + Arrays.toString(rowVector.shape()));    //1 row, 3 columns
 
-        INDArray columnVector = Nd4j.create(vectorDouble, new int[]{3,1});  //Manually specify: 3 rows, 1 column
+        INDArray columnVector = Nd4j.create(vectorDouble, 3,1);  //Manually specify: 3 rows, 1 column
         System.out.println("columnVector:           " + columnVector);      //Note for printing: row/column vectors are printed as one line
         System.out.println("columnVector.shape():   " + Arrays.toString(columnVector.shape()));    //3 row, 1 columns
 
@@ -71,6 +71,7 @@ public static void main(String[] args){
         //It is also possible to create random INDArrays:
         //Be aware however that by default, random values are printed with truncated precision using INDArray.toString()
         int[] shape = new int[]{nRows, nColumns};
+        long[] shape_long = new long []{nRows, nColumns};
         INDArray uniformRandom = Nd4j.rand(shape);
         System.out.println("\n\n\nUniform random array:");
         System.out.println(uniformRandom);
@@ -82,8 +83,8 @@ public static void main(String[] args){
 
         //We can make things repeatable using RNG seed:
         long rngSeed = 12345;
-        INDArray uniformRandom2 = Nd4j.rand(shape, rngSeed);
-        INDArray uniformRandom3 = Nd4j.rand(shape, rngSeed);
+        INDArray uniformRandom2 = Nd4j.rand(rngSeed, shape_long);
+        INDArray uniformRandom3 = Nd4j.rand(rngSeed, shape_long);
         System.out.println("\nUniform random arrays with same fixed seed:");
         System.out.println(uniformRandom2);
         System.out.println();