Returns the indices of non-zero element of the vector

@return indices in Databuffer
183425
@Override
    public DataBuffer getVectorCoordinates() {
        int idx;
        if (isRowVector()) {
            idx = 1;
        } else if (isColumnVector()) {
            idx = 0;
        } else {
            throw new UnsupportedOperationException();
        }

        // FIXME: int cast
        int[] temp = new int[(int) length()];
        for (int i = 0; i < length(); i++) {
            temp[i] = getUnderlyingIndicesOf(i).getInt(idx);
        }
        return Nd4j.createBuffer(temp);
    }
262768
public int[] getNonZeroIndices() {
        int[] nz = new int[negativeDimensions.length 
                           + positiveDimensions.length];
        System.arraycopy(negativeDimensions, 0, nz, 
                         0, negativeDimensions.length);
        System.arraycopy(positiveDimensions, 0, nz, 
                         negativeDimensions.length, positiveDimensions.length);
        return nz;
    }
482520
public double[][] getMaxedMarginals() {
    double[][] maxValues = new double[neighborIndices.length][];
    for (int i = 0; i < neighborIndices.length; i++) {
      maxValues[i] = new double[getDimensions()[i]];
      for (int j = 0; j < maxValues[i].length; j++) maxValues[i][j] = Double.NEGATIVE_INFINITY;
    }

    // Get max values

    // OPTIMIZATION:
    // Rather than use the standard iterator, which creates lots of int[] arrays on the heap, which need to be GC'd,
    // we use the fast version that just mutates one array. Since this is read once for us here, this is ideal.

    Iterator<int[]> fastPassByReferenceIterator = fastPassByReferenceIterator();
    int[] assignment = fastPassByReferenceIterator.next();
    while (true) {
      double v = getAssignmentLogValue(assignment);
      for (int i = 0; i < neighborIndices.length; i++) {
        if (maxValues[i][assignment[i]] < v) maxValues[i][assignment[i]] = v;
      }
      // This mutates the resultAssignment[] array, rather than creating a new one
      if (fastPassByReferenceIterator.hasNext()) {
        fastPassByReferenceIterator.next();
      } else break;
    }

    for (int i = 0; i < neighborIndices.length; i++) {
      normalizeLogArr(maxValues[i]);
    }

    return maxValues;
  }
280789
public Vector getOIDs()
    {
        Vector v = new Vector();

        for (int i = 0; i != ordering.size(); i++)
        {
            v.addElement(ordering.elementAt(i));
        }

        return v;
    }
194262
public String[] getIndexArr() {
		String[] indexArr = new String[this.from.size()];
		for (int i = 0; i < indexArr.length; i++) {
			indexArr[i] = this.from.get(i).getIndex();
		}
		return indexArr;
	}
714853
public static int getMaxValueIndex (int[] values)
    {
        if (values == null || values.length == 0) {
            return -1;
        }

        int idx = 0;
        int max = values[idx];
        for (int ii = 1; ii < values.length; ii++) {
            if (values[ii] > max) {
                max = values[ii];
                idx = ii;
            }
        }
        return idx;
    }
156956
public int[] getIC()
    {
        int[] ic = new int[nzmax];
        int i = 0;
        for ( IndexMN index : indexSet )
        {
            ic[i++] = index.n;
        }
        return ic;
    }
736253
public int[] getSparseIndices(int component) {
    assert (sparse[component]);
    int[] indices = new int[pointers[component].length / 2];
    for (int i = 0; i < pointers[component].length / 2; i++) {
      indices[i] = (int) pointers[component][i * 2];
    }
    return indices;
  }
1064454
public int[] getTenors() {
		Set<Integer> setTenors	= new HashSet<>();

		for(int moneyness : getGridNodesPerMoneyness().keySet()) {
			setTenors.addAll(Arrays.asList((IntStream.of(keyMap.get(moneyness)[1]).boxed().toArray(Integer[]::new))));
		}
		return setTenors.stream().sorted().mapToInt(Integer::intValue).toArray();
	}
118457
public int[] getUnsignedPixelValues(WritableRaster raster) {
		short[] pixelValues = getPixelValues(raster);
		int[] unsignedPixelValues = getUnsignedPixelValues(pixelValues);
		return unsignedPixelValues;
	}
408686
function getIndices(x, y) {
         if (this.indices.length === 0) {
           var points = this.points;
           var data = []; // flatten the points vector array

           for (var i = 0; i < points.length; i++) {
             // XXX Optimize me
             data.push(points[i].x);
             data.push(points[i].y);
           }

           this.indices = earcut_1(data);
         }

         return this.indices;
       }
897396
def not_zeros_indexes(vector)
      vector.chars.map.with_index do |bit, index|
        next if bit == '0'
        index
      end.compact
    end
1304888
public final int getIndex( int coordinate[] ) {
		int index = coordinate[0]*strides[0];
		for (int i = 1; i < coordinate.length; i++) {
			index += strides[i]*coordinate[i];
		}

		return index;
	}
482713
public int middleIndex()
  {
    int x = midPoint();
    int r = rightMostIndex();
    if (r < midPoint())
      x = r;
    return x;
  }
1039567
public int[] indices(Collection<E> elems) {
    int[] indices = new int[elems.size()];
    int i = 0;
    for (E elem : elems) {
      indices[i++] = indexOf(elem);
    }
    return indices;
  }
398905
public int getIndex() {
        if (parent != null) {
            for (int i = 0; i < parent.children.size(); i++) {
                if (parent.children.get(i) == this) {
                    return i;
                }
            }
        }
        
        return -1;
    }
1105729
public Vector3D getVertex(int index) {
        tmpV.setX(cornerX.get(index));
        tmpV.setY(cornerY.get(index));
        tmpV.setZ(cornerZ.get(index));
        calcG();
        return tmpV;
    }