public Vector solve(Matrix A, Vector b, Vector x) throws IterativeSolverNotConvergedException { checkSizes(A, b, x); double alpha = 0, beta = 0, rho = 0, rho_1 = 0; A.multAdd(-1, x, r.set(b)); for (iter.setFirst(); !iter.converged(r, x); iter.next()) { M.apply(r, z); rho = r.dot(z); if (iter.isFirst()) p.set(z); else { beta = rho / rho_1; p.scale(beta).add(z); } A.mult(p, q); alpha = rho / p.dot(q); x.add(alpha, p); r.add(-alpha, q); rho_1 = rho; } return x; }
@Override public Vector[] apply(double[] in) { Vector[] vmat = new Vector[in.length]; vmat[0] = new DenseVector(in); double norm = vmat[0].norm(Norm.Two); vmat[0].scale(1/norm); for (int j = 1; j < in.length; j++) { Vector randvec = randvec(vmat[0].size(),norm); vmat[j] = new DenseVector(vmat[0]).add(randvec); for (int i = 0; i < j; i++) { vmat[j].add(-1, project(vmat[j],vmat[i])); } vmat[j].scale(1/vmat[j].norm(Norm.Two)); } return vmat; }
/** * Returns the log of the density value for the given vector. * * @param valuePassed input vector * @return log density based on given distribution */ @Override public double logDensity(double[] valuePassed) { // calculate mean subtractions Vector x = new DenseVector(valuePassed); return lnconstant - 0.5 * x.dot(covarianceInverse.mult(x.add(-1.0, mean), new DenseVector(x.size()))); }
@Override public int getDimensionality() { return this.internalVector.size(); }
@Override public void set(int aParamInt, double aParamDouble) { wrapped.set(aParamInt, aParamDouble); }
@Override public double get( final int index) { return this.internalVector.get(index); }
/** * Classifies a given instance. * * @param inst the instance to be classified * @return the classification * @throws Exception if instance could not be classified successfully */ @Override public double classifyInstance(Instance inst) throws Exception { // Filter instance inst = filterInstance(inst); // Build K vector Vector k = new DenseVector(m_NumTrain); for (int i = 0; i < m_NumTrain; i++) { k.set(i, m_weights[i] * m_actualKernel.eval(-1, i, inst)); } double result = (k.dot(m_t) + m_avg_target - m_Blin) / m_Alin; return result; }
@Override public IndependentPair<double[], PerceptronClass> generate() { double decide = Math.signum(rng.nextDouble() - 0.5); if(decide == 0) decide = 1; PerceptronClass dec = PerceptronClass.fromSign(decide); while(true){ double[] randomPoint = new double[this.dims]; for (int i = 0; i < randomPoint.length; i++) { randomPoint[i] = nextRandomValue(); } Vector v = new DenseVector(randomPoint); v.add(-1, origin); Vector d = direction.copy(); double dot = v.dot(d); double sgn = Math.signum(dot); if(sgn == 0) sgn = 1; if(rng.nextDouble() <this.error){ sgn = -sgn; } PerceptronClass sgnClass = PerceptronClass.fromSign(sgn); if(sgnClass.equals(dec)) { return IndependentPair.pair(randomPoint, sgnClass); } } }
@Override public Vector get() { return vector.copy(); }
/** * Computes standard deviation for given instance, without transforming target * back into original space. */ protected double computeStdDev(Instance inst, Vector k) throws Exception { double kappa = m_actualKernel.eval(-1, -1, inst) + m_deltaSquared; double s = m_L.mult(k, new DenseVector(k.size())).dot(k); double sigma = m_delta; if (kappa > s) { sigma = Math.sqrt(kappa - s); } return sigma; }
@Override public void add(int aTimes, Vector aVector) { vector.add(aTimes, aVector); }
@Override public double norm2() { return this.internalVector.norm( no.uib.cipr.matrix.Vector.Norm.Two ); }
@Override public void scaleEquals( final double scaleFactor) { this.internalVector.scale( scaleFactor ); }
/** * Computes the mean vector for the given dataset. */ protected Vector computeMean(Instances data, double[] totalWeight, int aI) { Vector meanVector = new DenseVector(data.numAttributes() - 1); totalWeight[aI] = 0; for (Instance inst : data) { if (!inst.classIsMissing()) { meanVector.add(inst.weight(), instanceToVector(inst)); totalWeight[aI] += inst.weight(); } } meanVector.scale(1.0 / totalWeight[aI]); return meanVector; }