public void PermutationProduct() { Random rng = new Random(4); string s = "abcdefghijklmnopqrstuvwxyz"; for (int i = 0; i < 16; i++) { int n = rng.Next(2, s.Length); char[] c0 = s.Substring(0, n).ToCharArray(); char[] c1 = (char[])c0.Clone(); char[] c2 = (char[])c0.Clone(); Permutation p = Permutation.GetRandomPermutation(n, rng); Permutation q = Permutation.GetRandomPermutation(n, rng); q.Apply(c1); p.Apply(c1); string s1 = new String(c1); Permutation pq = p * q; pq.Apply(c2); string s2 = new String(c2); Console.WriteLine("{0} {1}", s1, s2); Assert.IsTrue(s1 == s2); } }
public SuperSlimBoard Permute(Permutation p, List <int> indices) { var trace = new ulong[_trace.Length]; var permutedIndices = p.Apply(indices); for (int i = 0; i < _trace.Length; i++) { var n = _trace[i]; var m = _trace[i]; for (int j = 0; j < indices.Count; j++) { m &= ~(1UL << indices[j]); } for (int j = 0; j < indices.Count; j++) { if ((n & (1UL << indices[j])) != 0) { m |= (1UL << permutedIndices[j]); } } trace[i] = m; } Array.Sort(trace); return(new SuperSlimBoard(trace, _stackCount)); }
/// <summary> /// Solves a linear system Ax=b, where A is symmetric positive definite. /// </summary> /// <param name="input">Right hand side b.</param> /// <param name="result">Solution vector x.</param> public void Solve(double[] input, double[] result) { if (input == null) { throw new ArgumentNullException("input"); } if (result == null) { throw new ArgumentNullException("result"); } double[] x = new double[n]; Permutation.ApplyInverse(S.pinv, input, x, n); // x = P*b var lx = L.Values; var lp = L.ColumnPointers; var li = L.RowIndices; var d = this.D; int end; // Solve lower triangular system by forward elimination, x = L\x. for (int i = 0; i < n; i++) { end = lp[i + 1]; for (int p = lp[i]; p < end; p++) { x[li[p]] -= lx[p] * x[i]; } } // Solve diagonal system, x = D\x. for (int i = 0; i < n; i++) { x[i] /= d[i]; } // Solve upper triangular system by backward elimination, x = L'\x. for (int i = n - 1; i >= 0; i--) { end = lp[i + 1]; for (int p = lp[i]; p < end; p++) { x[i] -= lx[p] * x[li[p]]; } } Permutation.Apply(S.pinv, x, result, n); // b = P'*x }
/// <summary> /// Solves a system of linear equations, <c>A'x = b</c>. /// </summary> /// <param name="input">The right hand side vector, <c>b</c>.</param> /// <param name="result">The left hand side vector, <c>x</c>.</param> public void SolveTranspose(Complex[] input, Complex[] result) { if (input == null) { throw new ArgumentNullException(nameof(input)); } if (result == null) { throw new ArgumentNullException(nameof(result)); } int m2 = S.m2; var x = new Complex[m2]; if (m >= n) { // x(q(0:m-1)) = b(0:m-1) Permutation.Apply(S.q, input, x, n); SolverHelper.SolveUpperTranspose(R, x); // x = R'\x // Apply Householder reflection to x. for (int k = n - 1; k >= 0; k--) { ApplyHouseholder(Q, k, beta[k], x); } // b(0:n-1) = x(p(0:n-1)) Permutation.Apply(S.pinv, x, result, m); } else { // x(0:m-1) = b(p(0:m-1) Permutation.ApplyInverse(S.pinv, input, x, n); // Apply Householder reflection to x. for (int k = 0; k < m; k++) { ApplyHouseholder(Q, k, beta[k], x); } SolverHelper.SolveUpper(R, x); // x = R\x // b(q(0:n-1)) = x(0:n-1) Permutation.ApplyInverse(S.q, x, result, m); } }
/// <summary> /// Solves a system of linear equations, <c>Ax = b</c>. /// </summary> /// <param name="input">The right hand side vector, <c>b</c>.</param> /// <param name="result">The left hand side vector, <c>x</c>.</param> /// <remarks> /// Let A be a m-by-n matrix. If m >= n a least-squares problem (min |Ax-b|) /// is solved. If m < n the underdetermined system is solved. /// </remarks> public override void Solve(double[] input, double[] result) { if (input == null) { throw new ArgumentNullException("input"); } if (result == null) { throw new ArgumentNullException("result"); } var x = new double[S.m2]; if (m >= n) { // x(0:m-1) = b(p(0:m-1) Permutation.ApplyInverse(S.pinv, input, x, m); // Apply Householder reflection to x. for (int k = 0; k < n; k++) { ApplyHouseholder(Q, k, beta[k], x); } SolverHelper.SolveUpper(R, x); // x = R\x // b(q(0:n-1)) = x(0:n-1) Permutation.ApplyInverse(S.q, x, result, n); } else { // x(q(0:m-1)) = b(0:m-1) Permutation.Apply(S.q, input, x, m); SolverHelper.SolveUpperTranspose(R, x); // x = R'\x // Apply Householder reflection to x. for (int k = m - 1; k >= 0; k--) { ApplyHouseholder(Q, k, beta[k], x); } // b(0:n-1) = x(p(0:n-1)) Permutation.Apply(S.pinv, x, result, n); } }
/// <summary> /// Solves a system of linear equations, <c>Ax = b</c>. /// </summary> /// <param name="input">The right hand side vector, <c>b</c>.</param> /// <param name="result">The left hand side vector, <c>x</c>.</param> public void Solve(Complex[] input, Complex[] result) { if (input == null) { throw new ArgumentNullException(nameof(input)); } if (result == null) { throw new ArgumentNullException(nameof(result)); } var x = this.temp; Permutation.ApplyInverse(S.pinv, input, x, n); // x = P*b SolverHelper.SolveLower(L, x); // x = L\x SolverHelper.SolveLowerTranspose(L, x); // x = L'\x Permutation.Apply(S.pinv, x, result, n); // b = P'*x }
/// <summary> /// Solves a system of linear equations, <c>A'x = b</c>. /// </summary> /// <param name="input">The right hand side vector, <c>b</c>.</param> /// <param name="result">The left hand side vector, <c>x</c>.</param> public void SolveTranspose(Complex[] input, Complex[] result) { if (input == null) { throw new ArgumentNullException("input"); } if (result == null) { throw new ArgumentNullException("result"); } var x = this.temp; Permutation.Apply(S.q, input, x, n); // x = Q'*b SolverHelper.SolveUpperTranspose(U, x); // x = U'\x. SolverHelper.SolveLowerTranspose(L, x); // x = L'\x. Permutation.Apply(pinv, x, result, n); // b = P'*x }
// TODO: implement SolveTranspose /// <summary> /// Solves a linear system Ax=b, where A is symmetric positive definite. /// </summary> /// <param name="b">Right hand side, overwritten with solution</param> public void Solve(double[] b) { if (b == null) { throw new ArgumentNullException("b"); } double[] x = new double[n]; Permutation.ApplyInverse(symFactor.pinv, b, x, n); // x = P*b var lx = L.Values; var lp = L.ColumnPointers; var li = L.RowIndices; // LinearSolve lower triangular system by forward elimination, x = L\x. for (int i = 0; i < n; i++) { x[i] /= lx[lp[i]]; for (int p = lp[i] + 1; p < lp[i + 1]; p++) { x[li[p]] -= lx[p] * x[i]; } } // LinearSolve upper triangular system by backward elimination, x = L'\x. for (int i = n - 1; i >= 0; i--) { for (int p = lp[i] + 1; p < lp[i + 1]; p++) { x[i] -= lx[p] * x[li[p]]; } x[i] /= lx[lp[i]]; } Permutation.Apply(symFactor.pinv, x, b, n); // b = P'*x }
// TODO: implement SolveTranspose /// <summary> /// LinearSolve a least-squares problem (min ||Ax-b||_2, where A is m-by-n /// with m >= n) or underdetermined system (Ax=b, where m < n) /// </summary> /// <param name="b">size max(m,n), b (size m) on input, x(size n) on output</param> /// <returns>true if successful, false on error</returns> public void Solve(double[] b) { if (b == null) { throw new ArgumentNullException("b"); } var x = new double[symFactor.m2]; var up = R.ColumnPointers; var ui = R.RowIndices; var ux = R.Values; if (m >= n) { // x(0:m-1) = b(p(0:m-1) Permutation.ApplyInverse(symFactor.pinv, b, x, m); // Apply Householder reflection to x. for (int k = 0; k < n; k++) { ApplyHouseholder(Q, k, beta[k], x); } // LinearSolve upper triangular system, x = R\x. for (int i = n - 1; i >= 0; i--) { x[i] /= ux[up[i + 1] - 1]; for (int p = up[i]; p < up[i + 1] - 1; p++) { x[ui[p]] -= ux[p] * x[i]; } } // b(q(0:n-1)) = x(0:n-1) Permutation.ApplyInverse(symFactor.q, x, b, n); } else { // x(q(0:m-1)) = b(0:m-1) Permutation.Apply(symFactor.q, b, x, m); // TODO: int n = R.ColumnCount; // LinearSolve lower triangular system, x = R'\x. for (int i = 0; i < n; i++) { for (int p = up[i]; p < up[i + 1] - 1; p++) { x[i] -= ux[p] * x[ui[p]]; } x[i] /= ux[up[i + 1] - 1]; } // Apply Householder reflection to x. for (int k = m - 1; k >= 0; k--) { ApplyHouseholder(Q, k, beta[k], x); } // b(0:n-1) = x(p(0:n-1)) Permutation.Apply(symFactor.pinv, x, b, n); } }
public ShuffleAnimation(IStack stack, Permutation permutation) { this.stack = (Stack)stack; newArrangement = permutation.Apply(stack.Pieces); }