public void TestTheBasics() { ISimple class1 = GoInterface <ISimple, SimpleClass> .From(new SimpleClass()); ISimple iface1 = GoInterface <ISimple, IDifferentName> .From(new SimpleClass()); ISimple struct1 = GoInterface <ISimple, SimpleStruct> .From(new SimpleStruct(10)); Assert.AreEqual(25, class1.Mutate(5)); Assert.AreEqual(25, iface1.Mutate(5)); Assert.AreEqual(70, struct1.Mutate(7)); SimpleBase class2 = GoInterface <SimpleBase, SimpleClass> .From(new SimpleClass()); SimpleBase iface2 = GoInterface <SimpleBase, IDifferentName> .From(new SimpleClass()); SimpleBase struct2 = GoInterface <SimpleBase, SimpleStruct> .From(new SimpleStruct(10)); for (int i = 0; i < 10; i++) { Assert.AreEqual(class1.Mutate(i), class2.Mutate(i)); Assert.AreEqual(iface1.Mutate(i), iface2.Mutate(i)); Assert.AreEqual(struct1.Mutate(i), struct2.Mutate(i)); } Assert.AreEqual("forwarded!", struct1.ToString()); Assert.AreEqual("forwarded!", struct2.ToString()); Assert.AreEqual(struct1.GetHashCode(), struct2.GetHashCode()); // Note that struct1.Equals(struct2) returns FALSE because struct2 is // not "really" a SimpleStruct. We must "unwrap" the right-hand side: Assert.That(struct1.Equals(GoInterface.Unwrap(struct2))); Assert.That(struct2.Equals(GoInterface.Unwrap(struct1))); }
public virtual void specify0 <T>(SimpleBase <T, DMatrixRMaj> a, params SimpleBase <T, DMatrixRMaj>[] inputs) where T : SimpleBase <T, DMatrixRMaj> { SimpleBase <T, DMatrixRMaj>[] array = new SimpleBase <T, DMatrixRMaj> [inputs.Length + 1]; Array.Copy(inputs, 0, array, 0, inputs.Length); array[inputs.Length] = a; specify(inputs); }
/** * Computes the QR decomposition of the provided matrix. * * @param A Matrix which is to be decomposed. Not modified. */ public void decompose(SimpleMatrix <DMatrixRMaj> A) { this.QR = A.copy() as SimpleMatrix <DMatrixRMaj>; int N = Math.Min(A.numCols(), A.numRows()); gammas = new double[A.numCols()]; for (int i = 0; i < N; i++) { // use extract matrix to get the column that is to be zeroed SimpleMatrix <DMatrixRMaj> v = QR.extractMatrix(i, SimpleMatrix <DMatrixRMaj> .END, i, i + 1) as SimpleMatrix <DMatrixRMaj>; double max = v.elementMaxAbs(); if (max > 0 && v.getNumElements() > 1) { // normalize to reduce overflow issues v = v.divide(max) as SimpleMatrix <DMatrixRMaj>; // compute the magnitude of the vector double tau = v.normF(); if (v.get(0) < 0) { tau *= -1.0; } double u_0 = v.get(0) + tau; double gamma = u_0 / tau; v = v.divide(u_0) as SimpleMatrix <DMatrixRMaj>; v.set(0, 1.0); // extract the submatrix of A which is being operated on SimpleBase <DMatrixRMaj> A_small = QR.extractMatrix(i, SimpleMatrix <DMatrixRMaj> .END, i, SimpleMatrix <DMatrixRMaj> .END); // A = (I - γ*u*u<sup>T</sup>)A A_small = A_small.plus(-gamma, v.mult(v.transpose()).mult(A_small)); // save the results QR.insertIntoThis(i, i, A_small); QR.insertIntoThis(i + 1, i, v.extractMatrix(1, SimpleMatrix <DMatrixRMaj> .END, 0, 1)); // Alternatively, the two lines above can be replaced with in-place equations // READ THE JAVADOC TO UNDERSTAND HOW THIS WORKS! // QR.equation("QR(i:,i:) = A","QR",i,"i",A_small,"A"); // QR.equation("QR((i+1):,i) = v(1:,0)","QR",i,"i",v,"v"); // save gamma for recomputing Q later on gammas[i] = gamma; } } }
public SimpleSVD(Matrix mat, bool compact) { this.mat = mat; this.is64 = mat is DMatrixRMaj; if (is64) { DMatrixRMaj m = (DMatrixRMaj)mat; svd = (SingularValueDecomposition <T>)DecompositionFactory_DDRM.svd(m.numRows, m.numCols, true, true, compact); } else { FMatrixRMaj m = (FMatrixRMaj)mat; svd = (SingularValueDecomposition <T>)DecompositionFactory_FDRM.svd(m.numRows, m.numCols, true, true, compact); } if (!svd.decompose((T)mat)) { throw new InvalidOperationException("Decomposition failed"); } U = SimpleMatrix <T> .wrap(svd.getU(null, false)); W = SimpleMatrix <T> .wrap(svd.getW(null)); V = SimpleMatrix <T> .wrap(svd.getV(null, false)); // order singular values from largest to smallest if (is64) { var um = U.getMatrix() as DMatrixRMaj; var wm = W.getMatrix() as DMatrixRMaj; var vm = V.getMatrix() as DMatrixRMaj; SingularOps_DDRM.descendingOrder(um, false, wm, vm, false); tol = SingularOps_DDRM.singularThreshold((SingularValueDecomposition_F64 <DMatrixRMaj>)svd); } else { var um = U.getMatrix() as FMatrixRMaj; var wm = W.getMatrix() as FMatrixRMaj; var vm = V.getMatrix() as FMatrixRMaj; SingularOps_FDRM.descendingOrder(um, false, wm, vm, false); tol = SingularOps_FDRM.singularThreshold((SingularValueDecomposition_F32 <FMatrixRMaj>)svd); } }
public virtual T convert <T, W>(SimpleBase <T, W> matrix) where T : SimpleBase <T, W> where W : Matrix { if (matrix.getType == commonType) { return((T)matrix); } if (!matrix.getType.isDense() && commonType.isDense()) { Console.Error.WriteLine("\n***** WARNING *****\n"); Console.Error.WriteLine("Converting a sparse to dense matrix automatically."); Console.Error.WriteLine("Current auto convert code isn't that smart and this might have been available"); } Matrix m = ConvertMatrixType.convert(matrix.mat, commonType); if (m == null) { throw new System.ArgumentException("Conversion from " + matrix.getType + " to " + commonType + " not possible"); } return((T)matrix.wrapMatrix(m)); }