private static void test02()
//****************************************************************************80
//
// Purpose:
//
// TEST02 tests VAN_DER_CORPUT_SEQUENCE.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 09 August 2016
//
// Author:
//
// John Burkardt
//
{
const int N = 1;
int i;
double[] r = Array.Empty <double>();
Console.WriteLine("");
Console.WriteLine("TEST02");
Console.WriteLine(" VAN_DER_CORPUT_SEQUENCE computes several elements of");
Console.WriteLine(" a van der Corput sequence on a single call.");
Console.WriteLine("");
Console.WriteLine(" In this test, we call VAN_DER_CORPUT_SEQUENCE once.");
const int base_ = 2;
VanDerCorput.van_der_corput_base_set(base_);
const int seed = 0;
VanDerCorput.van_der_corput_seed_set(seed);
VanDerCorput.van_der_corput_sequence(N, ref r);
Console.WriteLine("");
Console.WriteLine(" Element van der Corput");
Console.WriteLine("");
for (i = 0; i < N; i++)
{
Console.WriteLine(i.ToString(CultureInfo.InvariantCulture).PadLeft(6) + " "
+ r[i].ToString(CultureInfo.InvariantCulture).PadLeft(10) + "");
}
}
private static void test06()
//****************************************************************************80
//
// Purpose:
//
// TEST06 tests I4_TO_VAN_DER_CORPUT_SEQUENCE.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 09 August 2016
//
// Author:
//
// John Burkardt
//
{
const int N = 10;
int base_;
double[] r = new double[N];
Console.WriteLine("");
Console.WriteLine("TEST06");
Console.WriteLine(" I4_TO_VAN_DER_CORPUT_SEQUENCE returns N elements");
Console.WriteLine(" of a van der Corput sequence to a given base.");
Console.WriteLine("");
Console.WriteLine("");
Console.WriteLine(" Base Seed R");
Console.WriteLine("");
for (base_ = 2; base_ <= 5; base_++)
{
Console.WriteLine("");
Console.WriteLine(base_.ToString(CultureInfo.InvariantCulture).PadLeft(6) + "");
int seed = 0;
VanDerCorput.i4_to_van_der_corput_sequence(seed, base_, N, ref r);
int i;
for (i = 0; i < N; i++)
{
Console.WriteLine(" "
+ (seed + i).ToString(CultureInfo.InvariantCulture).PadLeft(6) + " "
+ r[i].ToString(CultureInfo.InvariantCulture).PadLeft(10) + "");
}
}
}
private static void test05()
//****************************************************************************80
//
// Purpose:
//
// TEST05 tests I4_TO_VAN_DER_CORPUT.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 09 August 2016
//
// Author:
//
// John Burkardt
//
{
int base_;
Console.WriteLine("");
Console.WriteLine("TEST05");
Console.WriteLine(" I4_TO_VAN_DER_CORPUT returns the I-th element");
Console.WriteLine(" of a van der Corput sequence to a given base.");
Console.WriteLine("");
Console.WriteLine("");
Console.WriteLine(" Base Seed R");
Console.WriteLine("");
for (base_ = 2; base_ <= 5; base_++)
{
Console.WriteLine("");
Console.WriteLine(base_.ToString(CultureInfo.InvariantCulture).PadLeft(6) + "");
int seed;
for (seed = 0; seed <= 10; seed++)
{
double r = VanDerCorput.i4_to_van_der_corput(seed, base_);
Console.WriteLine(" "
+ seed.ToString(CultureInfo.InvariantCulture).PadLeft(6) + " "
+ r.ToString(CultureInfo.InvariantCulture).PadLeft(10) + "");
}
}
}
public static void van_der_corput_values_test()
//****************************************************************************80
//
// Purpose:
//
// VAN_DER_CORPUT_VALUES_TEST tests VAN_DER_CORPUT_VALUES.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 12 June 2007
//
// Author:
//
// John Burkardt
//
{
int base_ = 0;
int seed = 0;
double value = 0;
Console.WriteLine("");
Console.WriteLine("VAN_DER_CORPUT_VALUES_TEST:");
Console.WriteLine(" VAN_DER_CORPUT_VALUES stores values of");
Console.WriteLine(" the van der Corput sequence in a given base.");
Console.WriteLine("");
Console.WriteLine(" BASE SEED VDC(BASE,SEED)");
Console.WriteLine("");
int n_data = 0;
for (;;)
{
VanDerCorput.van_der_corput_values(ref n_data, ref base_, ref seed, ref value);
if (n_data == 0)
{
break;
}
Console.WriteLine(" "
+ base_.ToString().PadLeft(8) + " "
+ seed.ToString().PadLeft(8) + " "
+ value.ToString(CultureInfo.InvariantCulture).PadLeft(14) + "");
}
}
private static void test01()
//****************************************************************************80
//
// Purpose:
//
// TEST01 tests VAN_DER_CORPUT.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 09 August 2016
//
// Author:
//
// John Burkardt
//
{
int i;
Console.WriteLine("");
Console.WriteLine("TEST01");
Console.WriteLine(" VAN_DER_CORPUT computes the elements of a");
Console.WriteLine(" van der Corput sequence.");
Console.WriteLine(" Each call produces the next value. By default,");
Console.WriteLine(" the base is 2, and the sequence starts at element 1.");
Console.WriteLine("");
Console.WriteLine(" In this test, we call VAN_DER_CORPUT several times.");
Console.WriteLine("");
Console.WriteLine(" Seed van der Corput");
Console.WriteLine("");
for (i = 1; i <= 10; i++)
{
int seed = VanDerCorput.van_der_corput_seed_get();
double r = VanDerCorput.van_der_corput();
Console.WriteLine(seed.ToString(CultureInfo.InvariantCulture).PadLeft(6) + " "
+ r.ToString(CultureInfo.InvariantCulture).PadLeft(10) + "");
}
}
private static void test09()
//****************************************************************************80
//
// Purpose:
//
// TEST09 tests VDC_NUMERATOR_SEQUENCE.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 03 February 2011
//
// Author:
//
// John Burkardt
//
{
int n;
Console.WriteLine("");
Console.WriteLine("TEST09");
Console.WriteLine(" VDC_NUMERATOR_SEQUENCE returns N elements");
Console.WriteLine(" of a van der Corput numerator sequence in base 2.");
Console.WriteLine("");
Console.WriteLine(" N: Sequence");
Console.WriteLine("");
for (n = 1; n <= 20; n++)
{
int[] r = VanDerCorput.vdc_numerator_sequence(n);
string cout = " " + n.ToString(CultureInfo.InvariantCulture).PadLeft(2) + ":";
int i;
for (i = 0; i < n; i++)
{
cout += " " + r[i].ToString(CultureInfo.InvariantCulture).PadLeft(2);
}
Console.WriteLine(cout);
}
}
private static void vdc_base_test()
//****************************************************************************80
//
// Purpose:
//
// VDC_BASE_TEST tests VDC_BASE.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 10 August 2016
//
// Author:
//
// John Burkardt
//
{
int i;
Console.WriteLine("");
Console.WriteLine("VDC_BASE_TEST");
Console.WriteLine(" VDC_BASE returns the I-th element of a van der Corput");
Console.WriteLine(" sequence in base B.");
Console.WriteLine("");
Console.WriteLine(" I VDC_BASE(I,2) VDC_BASE(I,3) VDC_BASE(I,5)");
Console.WriteLine("");
for (i = -10; i <= 10; i++)
{
double r2 = VanDerCorput.vdc_base(i, 2);
double r3 = VanDerCorput.vdc_base(i, 3);
double r5 = VanDerCorput.vdc_base(i, 5);
Console.WriteLine(" " + i.ToString(CultureInfo.InvariantCulture).PadLeft(3)
+ " " + r2.ToString(CultureInfo.InvariantCulture).PadLeft(14)
+ " " + r3.ToString(CultureInfo.InvariantCulture).PadLeft(14)
+ " " + r5.ToString(CultureInfo.InvariantCulture).PadLeft(14) + "");
}
}
private static void vdc_inverse_test()
//****************************************************************************80
//
// Purpose:
//
// VDC_INVERSE_TEST tests VDC_INVERSE.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 10 August 2016
//
// Author:
//
// John Burkardt
//
{
int i;
Console.WriteLine("");
Console.WriteLine("VDC_INVERSE_TEST");
Console.WriteLine(" VDC_INVERSE inverts an element of a van der Corput sequence.");
Console.WriteLine("");
Console.WriteLine(" I R=VDC(I) VDC_INVERSE(R)");
Console.WriteLine("");
for (i = -10; i <= 10; i++)
{
double r = VanDerCorput.vdc(i);
int i2 = VanDerCorput.vdc_inverse(r);
Console.WriteLine(" " + i.ToString(CultureInfo.InvariantCulture).PadLeft(3)
+ " " + r.ToString(CultureInfo.InvariantCulture).PadLeft(14)
+ " " + i2.ToString(CultureInfo.InvariantCulture).PadLeft(3) + "");
}
}
private static void Main(string[] args)
//****************************************************************************80
//
// Purpose:
//
// MAIN is the main program for VAN_DER_CORPUT_DATASET.
//
// Discussion:
//
// VAN_DER_CORPUT_DATASET generates a van der Corput dataset.
//
// This program is meant to be used interactively. It's also
// possible to prepare a simple input file beforehand and use it
// in batch mode.
//
// Usage:
//
// van_der_corput_dataset base seed n
//
// where
//
// * BASE, the base of the sequence;
// * SEED, the index of the first element to be computed;
// * N, the number of points to generate.
//
// The program generates the data and writes it to the file
//
// van_der_corput_BASE_SEED_N.txt
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 09 December 2009
//
// Author:
//
// John Burkardt
//
{
int base_;
int n;
int seed;
Console.WriteLine("");
Console.WriteLine("VAN_DER_CORPUT_DATASET");
Console.WriteLine("");
Console.WriteLine(" Generate a van der Corput dataset.");
Console.WriteLine("");
Console.WriteLine(" The program requests input values from the user:"******"");
Console.WriteLine(" * BASE, the base,");
Console.WriteLine(" * SEED, a positive integer.");
Console.WriteLine(" * N, the number of points to generate,");
Console.WriteLine("");
Console.WriteLine(" The program generates the data, writes it to the file");
Console.WriteLine("");
Console.WriteLine(" van_der_corput_BASE_SEED_N.txt");
Console.WriteLine("");
//
// Get the BASE.
//
try
{
base_ = Convert.ToInt32(args[0]);
}
catch
{
Console.WriteLine("");
Console.WriteLine(" Enter BASE, the van der Corput base,");
Console.WriteLine(" which is often a prime number:");
Console.WriteLine(" (Try '2' if you don't have a preference.)");
base_ = Convert.ToInt32(Console.ReadLine());
}
Console.WriteLine("");
Console.WriteLine(" BASE = " + base_ + "");
//
// Get SEED.
//
try
{
seed = Convert.ToInt32(args[1]);
}
catch
{
Console.WriteLine("");
Console.WriteLine(" Enter SEED, which is 0 or a positive integer.");
Console.WriteLine(" (Try '0' or '1' if you don't have a preference.)");
seed = Convert.ToInt32(Console.ReadLine());
}
Console.WriteLine(" SEED = " + seed + "");
//
// Get N.
//
try
{
n = Convert.ToInt32(args[2]);
}
catch
{
Console.WriteLine("");
Console.WriteLine(" Enter N, the number of points to generate:");
Console.WriteLine(" (Try '25' if you don't have a preference.)");
n = Convert.ToInt32(Console.ReadLine());
}
Console.WriteLine(" N = " + n + "");
//
// Compute the data.
//
double[] r = new double[n];
VanDerCorput.i4_to_van_der_corput_sequence(seed, base_, n, ref r);
//
// Write the data to a file.
//
string output_filename = "van_der_corput_" + base_ + "_" + seed + "_" + n + ".txt";
typeMethods.r8mat_write(output_filename, 1, n, r);
Console.WriteLine("");
Console.WriteLine(" The data was written to the file \""
+ output_filename + "\".");
Console.WriteLine("");
Console.WriteLine("VAN_DER_CORPUT_DATASET:");
Console.WriteLine(" Normal end of execution.");
Console.WriteLine("");
}
private static void test045()
//****************************************************************************80
//
// Purpose:
//
// TEST045 tests VAN_DER_CORPUT, VAN_DER_CORPUT_SEED_GET, VAN_DER_CORPUT_SEED_SET.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 09 August 2016
//
// Author:
//
// John Burkardt
//
{
int i;
double r;
Console.WriteLine("");
Console.WriteLine("TEST045");
Console.WriteLine(" VAN_DER_CORPUT_SEED_GET gets the current seed.");
Console.WriteLine(" VAN_DER_CORPUT_SEED_SET sets the current seed.");
Console.WriteLine("");
Console.WriteLine(" The van der Corput base is usually a prime, but this is");
Console.WriteLine(" not required.");
Console.WriteLine("");
Console.WriteLine(" In this test, we compute a van der Corput sequence");
Console.WriteLine(" starting with the default seed, then check the seed,");
Console.WriteLine(" reset the seed, and recompute the sequence.");
int base_ = 2;
VanDerCorput.van_der_corput_base_set(base_);
int seed = 0;
VanDerCorput.van_der_corput_seed_set(seed);
Console.WriteLine("");
Console.WriteLine(" All computations will use base " + base_ + ".");
Console.WriteLine("");
seed = VanDerCorput.van_der_corput_seed_get();
Console.WriteLine("");
Console.WriteLine(" Set SEED = " + seed + "");
Console.WriteLine("");
Console.WriteLine(" Seed van der Corput");
Console.WriteLine("");
for (i = 1; i <= 10; i++)
{
seed = VanDerCorput.van_der_corput_seed_get();
r = VanDerCorput.van_der_corput();
Console.WriteLine(seed.ToString(CultureInfo.InvariantCulture).PadLeft(6) + " "
+ r.ToString(CultureInfo.InvariantCulture).PadLeft(10) + "");
}
seed = VanDerCorput.van_der_corput_seed_get();
Console.WriteLine("");
Console.WriteLine(" Current seed is " + seed + "");
Console.WriteLine("");
seed = 100;
VanDerCorput.van_der_corput_seed_set(seed);
Console.WriteLine("");
Console.WriteLine(" Set SEED = " + seed + "");
Console.WriteLine("");
Console.WriteLine(" Seed van der Corput");
Console.WriteLine("");
for (i = 1; i <= 10; i++)
{
seed = VanDerCorput.van_der_corput_seed_get();
r = VanDerCorput.van_der_corput();
Console.WriteLine(seed.ToString(CultureInfo.InvariantCulture).PadLeft(6) + " "
+ r.ToString(CultureInfo.InvariantCulture).PadLeft(10) + "");
}
seed = VanDerCorput.van_der_corput_seed_get();
Console.WriteLine("");
Console.WriteLine(" Current seed is " + seed + "");
Console.WriteLine("");
seed = 3;
VanDerCorput.van_der_corput_seed_set(seed);
Console.WriteLine("");
Console.WriteLine(" Reset seed to " + seed + "");
Console.WriteLine("");
Console.WriteLine(" Seed van der Corput");
Console.WriteLine("");
for (i = 1; i <= 10; i++)
{
seed = VanDerCorput.van_der_corput_seed_get();
r = VanDerCorput.van_der_corput();
Console.WriteLine(seed.ToString(CultureInfo.InvariantCulture).PadLeft(6) + " "
+ r.ToString(CultureInfo.InvariantCulture).PadLeft(10) + "");
}
}
private static void test03()
//****************************************************************************80
//
// Purpose:
//
// TEST03 tests VAN_DER_CORPUT_SEQUENCE, VAN_DER_CORPUT_SEED_GET, VAN_DER_CORPUT_SEED_SET.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 09 August 2016
//
// Author:
//
// John Burkardt
//
{
const int NMAX = 10;
int i;
double[] r = new double[NMAX];
Console.WriteLine("");
Console.WriteLine("TEST03");
Console.WriteLine(" VAN_DER_CORPUT_SEED_SET specifies the next element of");
Console.WriteLine(" the van der Corput sequence to compute.");
Console.WriteLine(" VAN_DER_CORPUT_SEED_GET reports the next element of the");
Console.WriteLine(" van der Corput sequence that will be computed.");
Console.WriteLine("");
Console.WriteLine(" By default, the sequence starts at element 1.");
Console.WriteLine("");
Console.WriteLine(" In this test, we demonstrate computing elements");
Console.WriteLine(" affects the seed, and how resetting the seed determines");
Console.WriteLine(" the next element computed.");
Console.WriteLine("");
Console.WriteLine(" We start at element 0 and compute 10 elements.");
Console.WriteLine("");
int seed = 0;
VanDerCorput.van_der_corput_seed_set(seed);
int n = NMAX;
VanDerCorput.van_der_corput_sequence(n, ref r);
for (i = 0; i < n; i++)
{
Console.WriteLine((seed + i).ToString(CultureInfo.InvariantCulture).PadLeft(6) + " "
+ r[i].ToString(CultureInfo.InvariantCulture).PadLeft(10) + "");
}
seed = VanDerCorput.van_der_corput_seed_get();
Console.WriteLine("");
Console.WriteLine(" The current seed is " + seed + "");
Console.WriteLine("");
Console.WriteLine(" We jump back to element 6 and compute 10 elements.");
Console.WriteLine("");
seed = 6;
VanDerCorput.van_der_corput_seed_set(seed);
n = NMAX;
VanDerCorput.van_der_corput_sequence(n, ref r);
for (i = 0; i < n; i++)
{
Console.WriteLine((seed + i).ToString(CultureInfo.InvariantCulture).PadLeft(6) + " "
+ r[i].ToString(CultureInfo.InvariantCulture).PadLeft(10) + "");
}
seed = VanDerCorput.van_der_corput_seed_get();
Console.WriteLine("");
Console.WriteLine(" The current seed is " + seed + "");
Console.WriteLine("");
Console.WriteLine(" We restart at element 0 and compute 6 elements.");
Console.WriteLine("");
seed = 0;
VanDerCorput.van_der_corput_seed_set(seed);
n = 6;
VanDerCorput.van_der_corput_sequence(n, ref r);
for (i = 0; i < n; i++)
{
Console.WriteLine((seed + i).ToString(CultureInfo.InvariantCulture).PadLeft(6) + " "
+ r[i].ToString(CultureInfo.InvariantCulture).PadLeft(10) + "");
}
seed = VanDerCorput.van_der_corput_seed_get();
Console.WriteLine("");
Console.WriteLine(" The current seed is " + seed + "");
Console.WriteLine("");
Console.WriteLine(" We jump to element 100 and compute 5 elements.");
Console.WriteLine("");
seed = 100;
VanDerCorput.van_der_corput_seed_set(seed);
n = 5;
VanDerCorput.van_der_corput_sequence(n, ref r);
for (i = 0; i < n; i++)
{
Console.WriteLine((seed + i).ToString(CultureInfo.InvariantCulture).PadLeft(6) + " "
+ r[i].ToString(CultureInfo.InvariantCulture).PadLeft(10) + "");
}
seed = VanDerCorput.van_der_corput_seed_get();
Console.WriteLine("");
Console.WriteLine(" The current seed is " + seed + "");
}
private static void vdc_sequence_test()
//****************************************************************************80
//
// Purpose:
//
// VDC_SEQUENCE_TEST tests VDC_SEQUENCE.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 10 August 2016
//
// Author:
//
// John Burkardt
//
{
Console.WriteLine("");
Console.WriteLine("VDC_SEQUENCE_TEST");
Console.WriteLine(" VDC_SEQUENCE returns elements I1 through I2 of");
Console.WriteLine(" a van der Corput sequence.");
int i1 = 7;
int i2 = 7;
int n = 1;
double[] r = VanDerCorput.vdc_sequence(i1, i2);
Console.WriteLine("");
typeMethods.r8vec_transpose_print(n, r, " R=VDC_SEQUENCE( 7, 7):");
i1 = 0;
i2 = 8;
n = i2 + 1;
r = VanDerCorput.vdc_sequence(i1, i2);
Console.WriteLine("");
typeMethods.r8vec_transpose_print(n, r, " R=VDC_SEQUENCE( 0, 8):");
i1 = 8;
i2 = 0;
n = Math.Abs(i2 - i1) + 1;
r = VanDerCorput.vdc_sequence(i1, i2);
Console.WriteLine("");
typeMethods.r8vec_transpose_print(n, r, " R=VDC_SEQUENCE( 8, 0):");
i1 = -3;
i2 = +5;
n = Math.Abs(i2 - i1) + 1;
r = VanDerCorput.vdc_sequence(i1, i2);
Console.WriteLine("");
typeMethods.r8vec_transpose_print(n, r, " R=VDC_SEQUENCE( -3, 5):");
i1 = 100;
i2 = 105;
n = Math.Abs(i2 - i1) + 1;
r = VanDerCorput.vdc_sequence(i1, i2);
Console.WriteLine("");
typeMethods.r8vec_transpose_print(n, r, " R=VDC_SEQUENCE(100,105):");
}
