@Override public int lengthSquared() { final int size = size(); int l = 0; for (int comp = 0; comp < size; comp++) { l += vec[comp] * vec[comp]; } return l; }
public int dot(int... v) { final int size = size(); if (size != v.length) { throw new IllegalArgumentException("Vector sizes must be the same"); } int d = 0; for (int comp = 0; comp < size; comp++) { d += vec[comp] * v[comp]; } return d; }
public VectorNi add(int... v) { final int size = size(); if (size != v.length) { throw new IllegalArgumentException("Vector sizes must be the same"); } final VectorNi d = new VectorNi(size); for (int comp = 0; comp < size; comp++) { d.vec[comp] = vec[comp] + v[comp]; } return d; }
@Override public VectorNl toLong() { final int size = size(); final long[] longVec = new long[size]; for (int comp = 0; comp < size; comp++) { longVec[comp] = (long) vec[comp]; } return new VectorNl(longVec); }
@Override public VectorNi abs() { final int size = size(); final VectorNi d = new VectorNi(size); for (int comp = 0; comp < size; comp++) { d.vec[comp] = Math.abs(vec[comp]); } return d; }
@Override public VectorNf toFloat() { final int size = size(); final float[] floatVec = new float[size]; for (int comp = 0; comp < size; comp++) { floatVec[comp] = (float) vec[comp]; } return new VectorNf(floatVec); }
public VectorNi resize(int size) { final VectorNi d = new VectorNi(size); System.arraycopy(vec, 0, d.vec, 0, Math.min(size, size())); return d; }
@Override public VectorNi div(int a) { final int size = size(); final VectorNi d = new VectorNi(size); for (int comp = 0; comp < size; comp++) { d.vec[comp] = vec[comp] / a; } return d; }
public VectorNi div(int... v) { final int size = size(); if (size != v.length) { throw new IllegalArgumentException("Vector sizes must be the same"); } final VectorNi d = new VectorNi(size); for (int comp = 0; comp < size; comp++) { d.vec[comp] = vec[comp] / v[comp]; } return d; }
public VectorNi min(int... v) { final int size = size(); if (size != v.length) { throw new IllegalArgumentException("Vector sizes must be the same"); } final VectorNi d = new VectorNi(size); for (int comp = 0; comp < size; comp++) { d.vec[comp] = Math.min(vec[comp], v[comp]); } return d; }
public VectorNi add(int... v) { final int size = size(); if (size != v.length) { throw new IllegalArgumentException("Vector sizes must be the same"); } final VectorNi d = new VectorNi(size); for (int comp = 0; comp < size; comp++) { d.vec[comp] = vec[comp] + v[comp]; } return d; }
public VectorNi mul(int... v) { final int size = size(); if (size != v.length) { throw new IllegalArgumentException("Vector sizes must be the same"); } final VectorNi d = new VectorNi(size); for (int comp = 0; comp < size; comp++) { d.vec[comp] = vec[comp] * v[comp]; } return d; }
public VectorNi div(int... v) { final int size = size(); if (size != v.length) { throw new IllegalArgumentException("Vector sizes must be the same"); } final VectorNi d = new VectorNi(size); for (int comp = 0; comp < size; comp++) { d.vec[comp] = vec[comp] / v[comp]; } return d; }
@Override public VectorNd toDouble() { final int size = size(); final double[] doubleVec = new double[size]; for (int comp = 0; comp < size; comp++) { doubleVec[comp] = (double) vec[comp]; } return new VectorNd(doubleVec); }
public VectorNi sub(int... v) { final int size = size(); if (size != v.length) { throw new IllegalArgumentException("Vector sizes must be the same"); } final VectorNi d = new VectorNi(size); for (int comp = 0; comp < size; comp++) { d.vec[comp] = vec[comp] - v[comp]; } return d; }
@Override public VectorNi div(int a) { final int size = size(); final VectorNi d = new VectorNi(size); for (int comp = 0; comp < size; comp++) { d.vec[comp] = vec[comp] / a; } return d; }
public VectorNi min(int... v) { final int size = size(); if (size != v.length) { throw new IllegalArgumentException("Vector sizes must be the same"); } final VectorNi d = new VectorNi(size); for (int comp = 0; comp < size; comp++) { d.vec[comp] = Math.min(vec[comp], v[comp]); } return d; }
public VectorNi max(int... v) { final int size = size(); if (size != v.length) { throw new IllegalArgumentException("Vector sizes must be the same"); } final VectorNi d = new VectorNi(size); for (int comp = 0; comp < size; comp++) { d.vec[comp] = Math.max(vec[comp], v[comp]); } return d; }
@Override public VectorNi toInt() { final int size = size(); final int[] intVec = new int[size]; for (int comp = 0; comp < size; comp++) { intVec[comp] = (int) vec[comp]; } return new VectorNi(intVec); }
@Override public VectorNi pow(int power) { final int size = size(); final VectorNi d = new VectorNi(size); for (int comp = 0; comp < size; comp++) { d.vec[comp] = GenericMath.floor(Math.pow(vec[comp], power)); } return d; }