@Override public <M extends Number> void sub(Vector<M> vector) { assert (vector.length() == data.length); if (vector instanceof IntVector) { final int[] data2 = ((IntVector) vector).data; for (int i = 0; i < data.length; i++) { data[i] -= data2[i]; } } else { for (Map.Entry<Integer, M> e : vector.entrySet()) { data[e.getKey()] -= e.getValue().intValue(); } } }
@Override public <M extends Number> void sub(Vector<M> vector) { assert (vector.length() == data.length); if (vector instanceof RealVector) { final double[] data2 = ((RealVector) vector).data; for (int i = 0; i < data.length; i++) { data[i] -= data2[i]; } } else { for (Map.Entry<Integer, M> e : vector.entrySet()) { data[e.getKey()] -= e.getValue().doubleValue(); } } }
@Override public <M extends Number> void add(Vector<M> vector) { assert (vector.length() == data.length); if (vector instanceof IntVector) { final int[] data2 = ((IntVector) vector).data; for (int i = 0; i < data.length; i++) { data[i] += data2[i]; } } else { for (Map.Entry<Integer, M> e : vector.entrySet()) { data[e.getKey()] += e.getValue().intValue(); } } }
@Override public <M extends Number> void add(Vector<M> vector) { assert (vector.length() == data.length); if (vector instanceof RealVector) { final double[] data2 = ((RealVector) vector).data; for (int i = 0; i < data.length; i++) { data[i] += data2[i]; } } else { for (Map.Entry<Integer, M> e : vector.entrySet()) { data[e.getKey()] += e.getValue().doubleValue(); } } }
@Override public <M extends Number> void add(Vector<M> vector) { assert (vector.length() == n); for (Map.Entry<Integer, M> e : vector.entrySet()) { add(e.getKey(), e.getValue().intValue()); } }
@Override public <M extends Number> void sub(Vector<M> vector) { assert (vector.length() == n); for (Map.Entry<Integer, M> e : vector.entrySet()) { sub(e.getKey(), e.getValue().intValue()); } }
@Override public <M extends Number> void add(Vector<M> vector) { assert (vector.length() == n); for (Map.Entry<Integer, M> e : vector.entrySet()) { add(e.getKey(), e.getValue().doubleValue()); } }
@Override public <M extends Number> void sub(Vector<M> vector) { assert (vector.length() == n); for (Map.Entry<Integer, M> e : vector.entrySet()) { sub(e.getKey(), e.getValue().doubleValue()); } }
private <O extends Number> Vector<O> invMap(Vector<O> x, Factory<O> using) { final Vector<O> x2 = using.make(map.length, 0.0); for (Map.Entry<Integer, O> e : x.entrySet()) { final int i = e.getKey(); if (invMap[i] >= 0) { x2.put(invMap[i], e.getValue()); } } return x2; }
@Override public boolean isSymmetric() { if (m != n) { return false; } for (int i = 0; i < m; i++) { if (arr[i] == null) { continue; } for (Map.Entry<Integer, N> e : arr[i].entrySet()) { if (arr[e.getKey()] == null) { return false; } if (arr[e.getKey()].value(i).doubleValue() != e.getValue().doubleValue()) { return false; } } } return true; }
@Override public <M extends Number> Vector<N> multTransposed(Vector<M> x) { assert (m == cols()); double[] result = new double[m]; Arrays.fill(result, m * defaultValue); for (int i = 0; i < arr.length; i++) { for (Map.Entry<Integer, N> e : arr[i].entrySet()) { result[e.getKey().intValue()] += x.doubleValue(i) * e.getValue().doubleValue() - defaultValue; } } return using.make(result); }
public static double kullbackLeiblerDivergence(Vector<Integer> vec1, Vector<Integer> vec2, final StopWordList stopWordList) { final double N1 = vec1.sum(), N2 = vec2.sum(); double kld = 0.0; for (Map.Entry<Integer, Integer> e : vec1.entrySet()) { if (stopWordList.contains(e.getKey())) { continue; } final int tfj = vec2.value(e.getKey()).intValue(); if (tfj != 0) { kld += (double) e.getValue() / N1 * Math.max(KLD_NEG_COST, Math.log(N2 / N1 * e.getValue() * tfj)); } else { kld += (double) e.getValue() / N1 * KLD_NEG_COST; } } return kld; }
public static double jaccardIndex(Vector<Integer> vec1, Vector<Integer> vec2, final StopWordList stopWordList) { int intersect = 0; int union = 0; for (Map.Entry<Integer, Integer> e : vec1.entrySet()) { if (stopWordList.contains(e.getKey())) { continue; } if (vec2.containsKey(e.getKey())) { intersect++; } union++; } for (Map.Entry<Integer, Integer> e : vec2.entrySet()) { if (stopWordList.contains(e.getKey())) { continue; } if (!vec1.containsKey(e.getValue())) { union++; } } return union == 0 ? 0.0 : (double) intersect / union; }
@Override public <M extends Number> double innerProduct(Vector<M> y) { assert (y.length() == data.length); if (y instanceof RealVector) { final RealVector y2 = (RealVector) y; double innerProduct = 0.0; for (int i = 0; i < data.length; i++) { innerProduct += data[i] * y2.data[i]; } return innerProduct; } else if (y.defaultValue().doubleValue() == 0.0) { double innerProduct = 0.0; for (Map.Entry<Integer, M> e : y.entrySet()) { innerProduct += data[e.getKey()] * e.getValue().doubleValue(); } return innerProduct; } else { double innerProduct = 0.0; for (int i = 0; i < data.length; i++) { innerProduct += data[i] * y.doubleValue(i); } return innerProduct; } }
@Override public <M extends Number, O extends Number> Vector<O> mult(Vector<M> x, Factory<O> using) { final Vector<O> x2 = using.make(A.rows(), 0.0); for (Map.Entry<Integer, M> e : x.entrySet()) { x2.put(map[e.getKey()], e.getValue().doubleValue()); } return invMap(A.mult(x2, using), using); }
@Override public <M extends Number> double innerProduct(Vector<M> y) { assert (y.length() == data.length); if (y instanceof IntVector) { final IntVector y2 = (IntVector) y; int innerProduct = 0; for (int i = 0; i < data.length; i++) { innerProduct += data[i] * y2.data[i]; } return innerProduct; } else if (y.defaultValue().doubleValue() == 0.0) { double innerProduct = 0.0; for (Map.Entry<Integer, M> e : y.entrySet()) { innerProduct += data[e.getKey()] * e.getValue().doubleValue(); } return innerProduct; } else { double innerProduct = 0.0; for (int i = 0; i < data.length; i++) { innerProduct += data[i] * y.doubleValue(i); } return innerProduct; } }
/** * Generate the transpose of this matrix * * @param using {@link AS_INT_ARRAY} or {@link AS_REAL_ARRAY} as appropriate * @return The transposed matrix */ @Override public SparseMatrix<N> transpose() { final SparseMatrix<N> t = new SparseMatrix<N>(n, m, defaultValue, using); for (int i = 0; i < m; i++) { if (arr[i] != null) { for (Map.Entry<Integer, N> e : arr[i].entrySet()) { final int j = e.getKey(); if (t.arr[j] == null) { t.arr[j] = using.make(m, defaultValue); } t.arr[j].put(i, e.getValue()); } } } return t; }
/** * Calculate AA^T where A is this matrix * * @param outerProduct The matrix to store the result in * @return */ public void selfOuterProduct(Matrix<N> outerProduct) { assert (outerProduct.cols() == m); assert (outerProduct.rows() == m); for (int i = 0; i < m; i++) { for (Map.Entry<Integer, N> e : arr[i].entrySet()) { for (int j = 0; j < m; j++) { final double v = arr[j].doubleValue(e.getKey()) * e.getValue().doubleValue(); if (v != 0.0) { outerProduct.add(i, j, v); } } } } }
/** * Calculate A^TA where A is this matrix * * @param innerProduct The matrix to store the result in * @return */ public void selfInnerProduct(Matrix<N> innerProduct) { assert (innerProduct.cols() == n); assert (innerProduct.rows() == n); for (int k = 0; k < n; k++) { for (Map.Entry<Integer, N> e : arr[k].entrySet()) { final int j = e.getKey(); for (int i = 0; i < n; i++) { final double v = arr[k].doubleValue(i) * e.getValue().doubleValue(); if (v != 0) { innerProduct.add(i, j, v); } } } } }
@Override public <M extends Number> Vector<N> multTransposed(Vector<M> x) { final Vector<N> x2 = A.factory().make(A.rows(), 0.0); for (Map.Entry<Integer, M> e : x.entrySet()) { x2.put(map[e.getKey()], e.getValue().doubleValue()); } return invMap(A.multTransposed(x2), A.factory()); }