public static void ksub_next4_test() //****************************************************************************80 // // Purpose: // // KSUB_NEXT4_TEST tests KSUB_NEXT4. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 02 December 2006 // // Author: // // John Burkardt // { const int K = 3; int[] a = new int[K]; const int n = 5; Console.WriteLine(""); Console.WriteLine("KSUB_NEXT4_TEST"); Console.WriteLine(" KSUB_NEXT4 generates K subsets of an N set."); Console.WriteLine(" N = " + n + ""); Console.WriteLine(" K = " + K + ""); Console.WriteLine(""); Console.WriteLine("Rank Subset"); Console.WriteLine(""); bool done = true; int rank = 0; for (;;) { Ksub.ksub_next4(n, K, ref a, ref done); if (done) { break; } rank += 1; string cout = rank.ToString().PadLeft(4) + " "; cout += " "; int i; for (i = 0; i < K; i++) { cout += a[i].ToString().PadLeft(4) + " "; } Console.WriteLine(cout); } }
public static void ksub_unrank_test() //****************************************************************************80 // // Purpose: // // KSUB_UNRANK_TEST tests KSUB_UNRANK. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 07 March 2007 // // Author: // // John Burkardt // { const int K = 3; int i; int[] a = new int[K]; const int n = 5; const int rank = 8; Console.WriteLine(""); Console.WriteLine("KSUB_UNRANK_TEST"); Console.WriteLine(" KSUB_UNRANK: find the K-subset of an N set"); Console.WriteLine(" of a given rank."); Console.WriteLine(""); Console.WriteLine(" For N = " + n + ""); Console.WriteLine(" and K = " + K + ""); Console.WriteLine(" and the desired rank is " + rank + ""); Ksub.ksub_unrank(K, rank, ref a); Console.WriteLine(""); Console.WriteLine(" The subset of the given rank is:"); Console.WriteLine(""); string cout = ""; for (i = 0; i < K; i++) { cout += a[i].ToString().PadLeft(4); } Console.WriteLine(cout); }
public static void ksub_rank_test() //****************************************************************************80 // // Purpose: // // KSUB_RANK_TEST tests KSUB_RANK. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 07 March 2007 // // Author: // // John Burkardt // { const int N = 6; const int K = 3; int[] a = { 1, 3, 5 }; int i; int rank = 0; Console.WriteLine(""); Console.WriteLine("KSUB_RANK_TEST"); Console.WriteLine(" KSUB_RANK: determine the rank of a K subset of an N set."); Console.WriteLine(""); Console.WriteLine(" For N = " + N + ""); Console.WriteLine(" and K = " + K + ""); Console.WriteLine(" the subset is:"); Console.WriteLine(""); string cout = ""; for (i = 0; i < K; i++) { cout += a[i].ToString().PadLeft(4); } Console.WriteLine(cout); Ksub.ksub_rank(K, a, ref rank); Console.WriteLine(""); Console.WriteLine(" The computed rank is " + rank + ""); }
public static void ksub_random4_test() //****************************************************************************80 // // Purpose: // // KSUB_RANDOM4_TEST tests KSUB_RANDOM4. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 07 March 2007 // // Author: // // John Burkardt // { const int K = 3; const int N = 5; int[] a = new int[N]; int i; Console.WriteLine(""); Console.WriteLine("KSUB_RANDOM4_TEST"); Console.WriteLine(" KSUB_RANDOM4 generates a random K subset of an N set."); Console.WriteLine(" Set size is N = " + N + ""); Console.WriteLine(" Subset size is K = " + K + ""); Console.WriteLine(""); int seed = 123456789; for (i = 1; i <= 10; i++) { string cout = ""; Ksub.ksub_random4(N, K, ref seed, ref a); int j; for (j = 0; j < K; j++) { cout += " " + a[j].ToString().PadLeft(3); } Console.WriteLine(cout); } }
public static void ksub_random5_test() //****************************************************************************80 // // Purpose: // // KSUB_RANDOM5_TEST tests KSUB_RANDOM5. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 09 June 2011 // // Author: // // John Burkardt // { int i; const int k = 5; const int n = 52; Console.WriteLine(""); Console.WriteLine("KSUB_RANDOM5_TEST"); Console.WriteLine(" KSUB_RANDOM5 generates a random K subset of an N set."); Console.WriteLine(" Set size is N = " + n + ""); Console.WriteLine(" Subset size is K = " + k + ""); Console.WriteLine(""); int seed = 123456789; for (i = 1; i <= 5; i++) { string cout = ""; int[] a = Ksub.ksub_random5(n, k, ref seed); int j; for (j = 0; j < k; j++) { cout += " " + a[j].ToString().PadLeft(3); } Console.WriteLine(cout); } }
public static double[] grid_in_cube01(int dim_num, int n, int center, ref int seed) //****************************************************************************80 // // Purpose: // // GRID_IN_CUBE01 generates a grid dataset in the unit hypercube. // // Discussion: // // N points are needed in a DIM_NUM dimensional space. // // The points are to lie on a uniform grid of side N_SIDE. // // Unless the N = N_SIDE^DIM_NUM for some N_SIDE, we can't use all the // points on a grid. What we do is find the smallest N_SIDE // that's big enough, and randomly omit some points. // // If N_SIDE is 4, then the choices in 1D are: // // A: 0, 1/3, 2/3, 1 // B: 1/5, 2/5, 3/5, 4/5 // C: 0, 1/4, 2/4, 3/4 // D: 1/4, 2/4, 3/4, 1 // E: 1/8, 3/8, 5/8, 7/8 // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 17 August 2004 // // Author: // // John Burkardt // // Parameters: // // Input, int DIM_NUM, the spatial dimension. // // Input, int N, the number of points. // // Input, int CENTER, specifies the 1D grid centering: // 1: first point is 0.0, last point is 1.0; // 2: first point is 1/(N+1), last point is N/(N+1); // 3: first point is 0, last point is (N-1)/N; // 4: first point is 1/N, last point is 1; // 5: first point is 1/(2*N), last point is (2*N-1)/(2*N); // // Input/output, int &SEED, a seed for the random number generator. // // Output, double GRID_IN_CUBE01[DIM_NUM*N], the points. // { int j; // // Find the dimension of the smallest grid with N points. // int n_side = grid_side(dim_num, n); // // We need to select N points out of N_SIDE^DIM_NUM set. // int n_grid = (int)Math.Pow(n_side, dim_num); // // Generate a random subset of N items from a set of size N_GRID. // int[] rank_list = new int[n]; Ksub.ksub_random2(n_grid, n, ref seed, ref rank_list); // // Must make one dummy call to TUPLE_NEXT_FAST with RANK = -1. // int rank = -1; int[] tuple = new int[dim_num]; BTupleData data = new() { base_ = new int[dim_num] }; BTuple.tuple_next_fast(ref data, n_side, dim_num, rank, ref tuple); // // Now generate the appropriate indices, and "center" them. // double[] r = new double[dim_num * n]; for (j = 0; j < n; j++) { rank = rank_list[j] - 1; BTuple.tuple_next_fast(ref data, n_side, dim_num, rank, ref tuple); int i; switch (center) { case 1: { for (i = 0; i < dim_num; i++) { r[i + j * dim_num] = (tuple[i] - 1) / (double)(n_side - 1); } break; } case 2: { for (i = 0; i < dim_num; i++) { r[i + j * dim_num] = tuple[i] / (double)(n_side + 1); } break; } case 3: { for (i = 0; i < dim_num; i++) { r[i + j * dim_num] = (tuple[i] - 1) / (double)n_side; } break; } case 4: { for (i = 0; i < dim_num; i++) { r[i + j * dim_num] = tuple[i] / (double)n_side; } break; } case 5: { for (i = 0; i < dim_num; i++) { r[i + j * dim_num] = (2 * tuple[i] - 1) / (double)(2 * n_side); } break; } } } return(r); }
public static void subset_by_size_next(int n, ref int[] a, ref int subsize, ref bool more, ref bool more2, ref int m, ref int m2) //****************************************************************************80 // // Purpose: // // SUBSET_BY_SIZE_NEXT returns all subsets of an N set, in order of size. // // Example: // // N = 4: // // 1 2 3 4 // 1 2 3 // 1 2 4 // 1 3 4 // 1 3 // 1 4 // 2 3 // 1 // 2 // 3 // (the empty set) // // Discussion: // // The subsets are returned in decreasing order of size, with the // empty set last. // // For a given size K, the K subsets are returned in lexicographic order. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 09 June 2015 // // Author: // // John Burkardt // // Parameters: // // Input, int N, the size of the set. // // Input/output, int A[N]. The entries A(1:SUBSIZE) contain // the elements of the subset. The elements are given in ascending // order. // // Output, int &SUBSIZE, the number of elements in the subset. // // Input/output, bool &MORE. Set MORE = FALSE before first call // for a new sequence of subsets. It then is set and remains // TRUE as long as the subset computed on this call is not the // final one. When the final subset is computed, MORE is set to // FALSE as a signal that the computation is done. // // Input/output, bool &MORE2, a variable for bookkeeping. // The user should declare this variable, but need not initialize it. // The output value from one call must be the input value for the next. // // Input/output, int &M, &M2, variables for bookkeeping. // The user should declare this variable, but need not initialize it. // The output value from one call must be the input value for the next. // { switch (more) { case false: subsize = n; more = true; more2 = false; m = 0; m2 = 0; break; default: { switch (more2) { case false: subsize -= 1; break; } break; } } switch (subsize) { // // Compute the next subset of size SUBSIZE. // case > 0: Ksub.ksub_next(n, subsize, ref a, ref more2, ref m, ref m2); break; case 0: more = false; break; } }
public static void ksub_next_test() //****************************************************************************80 // // Purpose: // // KSUB_NEXT_TEST tests KSUB_NEXT. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 28 May 2015 // // Author: // // John Burkardt // { int[] a = new int[3]; int i; Console.WriteLine(""); Console.WriteLine("KSUB_NEXT_TEST"); Console.WriteLine(" KSUB_NEXT generates all K subsets of an N set"); Console.WriteLine(" in lexicographic order."); Console.WriteLine(""); int rank = 0; const int n = 5; const int k = 3; for (i = 0; i < k; i++) { a[i] = 0; } bool more = false; int m = 0; int m2 = 0; for (;;) { Ksub.ksub_next(n, k, ref a, ref more, ref m, ref m2); rank += 1; string cout = rank.ToString().PadLeft(4) + " "; for (i = 0; i < k; i++) { cout += a[i].ToString().PadLeft(4); } Console.WriteLine(cout); if (!more) { break; } } }
public static void ksub_next2_test() //****************************************************************************80 // // Purpose: // // KSUB_NEXT2_TEST tests KSUB_NEXT2. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 02 December 2006 // // Author: // // John Burkardt // { const int K = 3; int[] a = new int[K]; const int n = 5; Console.WriteLine(""); Console.WriteLine("KSUB_NEXT2_TEST"); Console.WriteLine(" KSUB_NEXT2 generates the next K subset of an"); Console.WriteLine(" N set by the revolving door method."); Console.WriteLine(""); Console.WriteLine("Rank Subset Added Removed"); Console.WriteLine(""); // // KSUB_NEXT2 does not have a good way of stopping. // We will save the starting subset, and stop when the // new subset is the same as the starting one. // int i_in = 0; int i_out = 0; int rank = 0; typeMethods.i4vec_indicator1(K, ref a); for (;;) { rank += 1; string cout = rank.ToString().PadLeft(2) + " "; int i; for (i = 0; i < K; i++) { cout += a[i].ToString().PadLeft(2) + " "; } cout += " "; cout += i_in.ToString().PadLeft(2) + " "; Console.WriteLine(cout + i_out.ToString().PadLeft(2) + ""); Ksub.ksub_next2(n, K, ref a, ref i_in, ref i_out); bool more = false; for (i = 1; i <= K; i++) { if (a[i - 1] != i) { more = true; } } if (!more) { break; } } }
public static void ksub_to_compnz_test() //****************************************************************************80 // // Purpose: // // KSUB_TO_COMPNZ_TEST tests KSUB_TO_COMPNZ. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 05 December 2013 // // Author: // // John Burkardt // { int[] ac = new int[5]; int[] as_ = new int[4]; int i; int ks = 0; int ns = 0; Console.WriteLine(""); Console.WriteLine("KSUB_TO_COMPNZ_TEST"); Console.WriteLine(" KSUB_TO_COMPNZ returns the nonzero composition "); Console.WriteLine(" corresponding to a K subset."); int nc = 10; int kc = 5; int seed = 123456789; for (i = 1; i <= 5; i++) { Console.WriteLine(""); Comp.compnz_random(nc, kc, ref seed, ref ac); string cout = " COMPNZ:"; int j; for (j = 0; j < kc; j++) { cout += ac[j].ToString().PadLeft(4); } Console.WriteLine(cout); Comp.compnz_to_ksub(nc, kc, ac, ref ns, ref ks, ref as_); cout = " KSUB: "; for (j = 0; j < ks; j++) { cout += as_[j].ToString().PadLeft(4); } Console.WriteLine(cout); Ksub.ksub_to_compnz(ns, ks, as_, ref nc, ref kc, ref ac); cout = " COMPNZ:"; for (j = 0; j < kc; j++) { cout += ac[j].ToString().PadLeft(4); } Console.WriteLine(cout); } }
public static void ksub_next3_test() //****************************************************************************80 // // Purpose: // // KSUB_NEXT3_TEST tests KSUB_NEXT3. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 02 December 2006 // // Author: // // John Burkardt // { const int K = 3; int[] a = new int[K]; int i_in = 0; int i_out = 0; const int n = 5; Console.WriteLine(""); Console.WriteLine("KSUB_NEXT3_TEST"); Console.WriteLine(" KSUB_NEXT3 generates all K subsets of an N set"); Console.WriteLine(" using the revolving door method."); Console.WriteLine(""); Console.WriteLine("Rank Subset Added Removed"); Console.WriteLine(""); int rank = 0; bool more = false; for (;;) { Ksub.ksub_next3(n, K, ref a, ref more, ref i_in, ref i_out); rank += 1; string cout = rank.ToString().PadLeft(4) + " "; int i; for (i = 0; i < K; i++) { cout += a[i].ToString().PadLeft(2) + " "; } cout += " "; cout += i_in.ToString().PadLeft(2) + " "; Console.WriteLine(cout + i_out.ToString().PadLeft(2) + ""); if (!more) { break; } } }