public static void ksub_random2_test() //****************************************************************************80 // // Purpose: // // KSUB_RANDOM2_TEST tests KSUB_RANDOM2. // // 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; const int n = 5; Console.WriteLine(""); Console.WriteLine("KSUB_RANDOM2_TEST"); Console.WriteLine(" KSUB_RANDOM2 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 = ""; Ksub.ksub_random2(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 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); }