public static void QK21Rule(QuadFunction f, double a, double b, out double result, out double abserr, out double resabs, out double resasc)
{
double[] fv1 = new double[11];
double[] fv2 = new double[11];
QuadKronrod.IntegrationQK(11, xgk, wg, wgk, fv1, fv2, f, a, b, out result, out abserr, out resabs, out resasc);
}
public static void QK21Rule(QuadFunction f, double a, double b, out double result, out double abserr, out double resabs, out double resasc)
{
double[] fv1 = new double[11];
double[] fv2 = new double[11];
QuadKronrod.IntegrationQK(11, xgk, wg, wgk, fv1, fv2, f, a, b, out result, out abserr, out resabs, out resasc);
}
public static void IntegrationQK(int n, double[] xgk, double[] wg, double[] wgk, double[] fv1, double[] fv2,
QuadFunction f, double a, double b, out double result, out double abserr, out double resabs, out double resasc)
{
double center = 0.5 * (a + b);
double half_length = 0.5 * (b - a);
double abs_half_length = Math.Abs(half_length);
double f_center = f(center);
double result_gauss = 0;
double result_kronrod = f_center * wgk[n - 1];
double result_abs = Math.Abs(result_kronrod);
double result_asc = 0;
double mean = 0, err = 0;
if (n % 2 == 0)
{
result_gauss = f_center * wg[n / 2 - 1];
}
for (int j = 0; j < (n - 1) / 2; j++)
{
int jtw = j * 2 + 1;
double abscissa = half_length * xgk[jtw];
double fval1 = f(center - abscissa);
double fval2 = f(center + abscissa);
double fsum = fval1 + fval2;
fv1[jtw] = fval1;
fv2[jtw] = fval2;
result_gauss += wg[j] * fsum;
result_kronrod += wgk[jtw] * fsum;
result_abs += wgk[jtw] * (Math.Abs(fval1) + Math.Abs(fval2));
}
for (int j = 0; j < n / 2; j++)
{
int jtwm1 = j * 2;
double abscissa = half_length * xgk[jtwm1];
double fval1 = f(center - abscissa);
double fval2 = f(center + abscissa);
fv1[jtwm1] = fval1;
fv2[jtwm1] = fval2;
result_kronrod += wgk[jtwm1] * (fval1 + fval2);
result_abs += wgk[jtwm1] * (Math.Abs(fval1) + Math.Abs(fval2));
}
mean = result_kronrod * 0.5;
result_asc = wgk[n - 1] * Math.Abs(f_center - mean);
for (int j = 0; j < n - 1; j++)
{
result_asc += wgk[j] * (Math.Abs(fv1[j] - mean) + Math.Abs(fv2[j] - mean));
}
/* scale by the width of the integration region */
err = (result_kronrod - result_gauss) * half_length;
result_kronrod *= half_length;
result_abs *= abs_half_length;
result_asc *= abs_half_length;
result = result_kronrod;
resabs = result_abs;
resasc = result_asc;
abserr = Error.RescaleError(err, result_abs, result_asc);
}
public static void IntegrationQK(int n, double[] xgk, double[] wg, double[] wgk, double[] fv1, double[] fv2,
QuadFunction f, double a, double b, out double result, out double abserr, out double resabs, out double resasc)
{
double center = 0.5 * (a + b);
double half_length = 0.5 * (b - a);
double abs_half_length = Math.Abs(half_length);
double f_center = f(center);
double result_gauss = 0;
double result_kronrod = f_center * wgk[n - 1];
double result_abs = Math.Abs(result_kronrod);
double result_asc = 0;
double mean = 0, err = 0;
if (n % 2 == 0) {
result_gauss = f_center * wg[n / 2 - 1];
}
for (int j = 0; j < (n - 1) / 2; j++) {
int jtw = j * 2 + 1;
double abscissa = half_length * xgk[jtw];
double fval1 = f(center - abscissa);
double fval2 = f(center + abscissa);
double fsum = fval1 + fval2;
fv1[jtw] = fval1;
fv2[jtw] = fval2;
result_gauss += wg[j] * fsum;
result_kronrod += wgk[jtw] * fsum;
result_abs += wgk[jtw] * (Math.Abs(fval1) + Math.Abs(fval2));
}
for (int j = 0; j < n / 2; j++) {
int jtwm1 = j * 2;
double abscissa = half_length * xgk[jtwm1];
double fval1 = f(center - abscissa);
double fval2 = f(center + abscissa);
fv1[jtwm1] = fval1;
fv2[jtwm1] = fval2;
result_kronrod += wgk[jtwm1] * (fval1 + fval2);
result_abs += wgk[jtwm1] * (Math.Abs(fval1) + Math.Abs(fval2));
}
mean = result_kronrod * 0.5;
result_asc = wgk[n - 1] * Math.Abs(f_center - mean);
for (int j = 0; j < n - 1; j++) {
result_asc += wgk[j] * (Math.Abs(fv1[j] - mean) + Math.Abs(fv2[j] - mean));
}
/* scale by the width of the integration region */
err = (result_kronrod - result_gauss) * half_length;
result_kronrod *= half_length;
result_abs *= abs_half_length;
result_asc *= abs_half_length;
result = result_kronrod;
resabs = result_abs;
resasc = result_asc;
abserr = Error.RescaleError(err, result_abs, result_asc);
}
static void multirunQuadratic(int runs)
{
List <string> edata = new List <string> ();
List <string> ddata = new List <string> ();
int seed = Int32.Parse(Prompt("What seed do you want? (32 bit int only)"));
for (int z = 0; z < runs; z++)
{
string[] total = File.ReadAllLines("AllData.txt");
string[] fakes = File.ReadAllLines("FakeData.txt");
string[] reals = File.ReadAllLines("RealData.txt");
string[] corrected = new string[total.Length];
int[] indexes = new int[fakes.Length];
Stopwatch eWatch = new Stopwatch();
eWatch.Start();
// Console.Write(indexes[1]);
Random rand = new Random(seed);
QuadFunction fun = new QuadFunction(rand.Next(1000), rand.Next(1000), rand.Next(1000));
// Conso/le.WriteLine("Fakes: " + fakes.Length + "\nIndexes:" + indexes.Length);
for (int i = 0; i < fakes.Length; i++)
{
int index = SafeIndex(indexes, Math.Abs(fun.Evaluate(i * seed) % total.Length), total.Length);
// Console.WriteLine(index);
corrected[index] = fakes[i];
// Console.WriteLine(i);
indexes[i] = index;
}
int r = 0;
for (int i = 0; i < total.Length; i++)
{
if (r >= reals.Length)
{
Console.Write("ERROR\n");
break;
}
if (!indexes.Contains(i))
{
corrected[i] = reals[r];
r++;
}
}
eWatch.Stop();
// File.AppendAllText ("Info.txt", "\nTime for Quad Encryption: " + eWatch.ElapsedMilliseconds + "ms");
bool dupsFound = false;
for (int i = 0; i < total.Length; i++)
{
if (corrected[i] == null)
{
dupsFound = true;
break;
}
if (corrected[i].Trim().Equals(""))
{
dupsFound = true;
break;
}
}
if (dupsFound)
{
Console.WriteLine("FOUND DUPLICATES");
}
Stopwatch dWatch = new Stopwatch();
dWatch.Start();
string[] eReals = new string[reals.Length];
for (int i = 0; i < fakes.Length; i++)
{
int index = SafeIndex(indexes, Math.Abs(fun.Evaluate(i * seed) % total.Length), total.Length);
corrected[index] = "";
}
int rr = 0;
for (int i = 0; i < total.Length; i++)
{
if (rr >= eReals.Length)
{
break;
}
if (corrected[i] != null && !corrected[i].Trim().Equals(""))
{
eReals[rr] = corrected[i];
rr++;
}
}
dWatch.Stop();
ddata.Add((z + 1) + "," + dWatch.ElapsedMilliseconds);
edata.Add((z + 1) + "," + eWatch.ElapsedMilliseconds);
}
File.WriteAllLines("QuadEncryptionRun.csv", edata.ToArray());
AverageTaker("QuadEncryptionRun.csv");
File.WriteAllLines("QuadDecryptionRun.csv", ddata.ToArray());
AverageTaker("QuadDecryptionRun.csv");
}
public static void Integrate(QuadFunction f, double a, double b, double epsabs, double epsrel, int limit, out double result, out double abserr, IntegrationRule q)
{
double area, errsum;
double result0, abserr0, resabs0, resasc0;
double tolerance;
int iteration = 0;
int roundoff_type1 = 0, roundoff_type2 = 0, error_type = 0;
double round_off;
/* Initialize results */
IntegrationWorkspace workspace = new IntegrationWorkspace(limit, a, b);
result = 0;
abserr = 0;
if (epsabs <= 0 && (epsrel < 50 * QuadConst.dbl_eps || epsrel < 0.5e-28)) {
throw new ArgumentException("Tolerance cannot be achieved with given epsabs and epsrel");
}
/* perform the first integration */
q(f, a, b, out result0, out abserr0, out resabs0, out resasc0);
workspace.SetInitialResult(result0, abserr0);
/* Test on accuracy */
tolerance = Math.Max(epsabs, epsrel * Math.Abs(result0));
/* need IEEE rounding here to match original quadpack behavior */
round_off = 50 * QuadConst.dbl_eps * resabs0;
if (abserr0 <= round_off && abserr0 > tolerance) {
result = result0;
abserr = abserr0;
throw new InvalidOperationException("cannot reach tolerance because of roundoff error on first attempt");
}
else if ((abserr0 <= tolerance && abserr0 != resasc0) || abserr0 == 0.0) {
result = result0;
abserr = abserr0;
//return GSL_SUCCESS;
return;
}
else if (limit == 1) {
result = result0;
abserr = abserr0;
throw new InvalidOperationException("a maximum of one iteration was insufficient");
}
area = result0;
errsum = abserr0;
iteration = 1;
do {
double a1, b1, a2, b2;
double a_i, b_i, r_i, e_i;
double area1 = 0, area2 = 0, area12 = 0;
double error1 = 0, error2 = 0, error12 = 0;
double resasc1, resasc2;
double resabs1, resabs2;
/* Bisect the subinterval with the largest error estimate */
workspace.Retrieve(out a_i, out b_i, out r_i, out e_i);
a1 = a_i;
b1 = 0.5 * (a_i + b_i);
a2 = b1;
b2 = b_i;
q(f, a1, b1, out area1, out error1, out resabs1, out resasc1);
q(f, a2, b2, out area2, out error2, out resabs2, out resasc2);
area12 = area1 + area2;
error12 = error1 + error2;
errsum += (error12 - e_i);
area += area12 - r_i;
if (resasc1 != error1 && resasc2 != error2) {
double delta = r_i - area12;
if (Math.Abs(delta) <= 1.0e-5 * Math.Abs(area12) && error12 >= 0.99 * e_i) {
roundoff_type1++;
}
if (iteration >= 10 && error12 > e_i) {
roundoff_type2++;
}
}
tolerance = Math.Max(epsabs, epsrel * Math.Abs(area));
if (errsum > tolerance) {
if (roundoff_type1 >= 6 || roundoff_type2 >= 20) {
error_type = 2; /* round off error */
}
/* set error flag in the case of bad integrand behaviour at
a point of the integration range */
if (workspace.SubintervalTooSmall(a1, a2, b2)) {
error_type = 3;
}
}
workspace.Update(a1, b1, area1, error1, a2, b2, area2, error2);
workspace.Retrieve(out a_i, out b_i, out r_i, out e_i);
iteration++;
}
while (iteration < limit && (error_type == 0) && errsum > tolerance);
result = workspace.SumResults();
abserr = errsum;
if (errsum <= tolerance) {
//return GSL_SUCCESS;
}
else if (error_type == 2) {
throw new InvalidOperationException("roundoff error prevents tolerance from being achieved");
/*GSL_ERROR ("roundoff error prevents tolerance from being achieved",
GSL_EROUND);*/
}
else if (error_type == 3) {
throw new InvalidOperationException("bad integrand found in the integration interval");
/*GSL_ERROR ("bad integrand behavior found in the integration interval",
GSL_ESING);*/
}
else if (iteration == limit) {
//GSL_ERROR ("maximum number of subdivisions reached", GSL_EMAXITER);
throw new InvalidOperationException("maximum number of subdivisions reached");
}
else {
//GSL_ERROR ("could not integrate function", GSL_EFAILED);
throw new InvalidOperationException("could not integrate function");
}
}
public static void Integrate(QuadFunction f, double a, double b, double epsabs, double epsrel, int limit, out double result, out double abserr, IntegrationRule q)
{
double area, errsum;
double result0, abserr0, resabs0, resasc0;
double tolerance;
int iteration = 0;
int roundoff_type1 = 0, roundoff_type2 = 0, error_type = 0;
double round_off;
/* Initialize results */
IntegrationWorkspace workspace = new IntegrationWorkspace(limit, a, b);
result = 0;
abserr = 0;
if (epsabs <= 0 && (epsrel < 50 * QuadConst.dbl_eps || epsrel < 0.5e-28))
{
throw new ArgumentException("Tolerance cannot be achieved with given epsabs and epsrel");
}
/* perform the first integration */
q(f, a, b, out result0, out abserr0, out resabs0, out resasc0);
workspace.SetInitialResult(result0, abserr0);
/* Test on accuracy */
tolerance = Math.Max(epsabs, epsrel * Math.Abs(result0));
/* need IEEE rounding here to match original quadpack behavior */
round_off = 50 * QuadConst.dbl_eps * resabs0;
if (abserr0 <= round_off && abserr0 > tolerance)
{
result = result0;
abserr = abserr0;
throw new InvalidOperationException("cannot reach tolerance because of roundoff error on first attempt");
}
else if ((abserr0 <= tolerance && abserr0 != resasc0) || abserr0 == 0.0)
{
result = result0;
abserr = abserr0;
//return GSL_SUCCESS;
return;
}
else if (limit == 1)
{
result = result0;
abserr = abserr0;
throw new InvalidOperationException("a maximum of one iteration was insufficient");
}
area = result0;
errsum = abserr0;
iteration = 1;
do
{
double a1, b1, a2, b2;
double a_i, b_i, r_i, e_i;
double area1 = 0, area2 = 0, area12 = 0;
double error1 = 0, error2 = 0, error12 = 0;
double resasc1, resasc2;
double resabs1, resabs2;
/* Bisect the subinterval with the largest error estimate */
workspace.Retrieve(out a_i, out b_i, out r_i, out e_i);
a1 = a_i;
b1 = 0.5 * (a_i + b_i);
a2 = b1;
b2 = b_i;
q(f, a1, b1, out area1, out error1, out resabs1, out resasc1);
q(f, a2, b2, out area2, out error2, out resabs2, out resasc2);
area12 = area1 + area2;
error12 = error1 + error2;
errsum += (error12 - e_i);
area += area12 - r_i;
if (resasc1 != error1 && resasc2 != error2)
{
double delta = r_i - area12;
if (Math.Abs(delta) <= 1.0e-5 * Math.Abs(area12) && error12 >= 0.99 * e_i)
{
roundoff_type1++;
}
if (iteration >= 10 && error12 > e_i)
{
roundoff_type2++;
}
}
tolerance = Math.Max(epsabs, epsrel * Math.Abs(area));
if (errsum > tolerance)
{
if (roundoff_type1 >= 6 || roundoff_type2 >= 20)
{
error_type = 2; /* round off error */
}
/* set error flag in the case of bad integrand behaviour at
* a point of the integration range */
if (workspace.SubintervalTooSmall(a1, a2, b2))
{
error_type = 3;
}
}
workspace.Update(a1, b1, area1, error1, a2, b2, area2, error2);
workspace.Retrieve(out a_i, out b_i, out r_i, out e_i);
iteration++;
}while (iteration < limit && (error_type == 0) && errsum > tolerance);
result = workspace.SumResults();
abserr = errsum;
if (errsum <= tolerance)
{
//return GSL_SUCCESS;
}
else if (error_type == 2)
{
throw new InvalidOperationException("roundoff error prevents tolerance from being achieved");
/*GSL_ERROR ("roundoff error prevents tolerance from being achieved",
* GSL_EROUND);*/
}
else if (error_type == 3)
{
throw new InvalidOperationException("bad integrand found in the integration interval");
/*GSL_ERROR ("bad integrand behavior found in the integration interval",
* GSL_ESING);*/
}
else if (iteration == limit)
{
//GSL_ERROR ("maximum number of subdivisions reached", GSL_EMAXITER);
throw new InvalidOperationException("maximum number of subdivisions reached");
}
else
{
//GSL_ERROR ("could not integrate function", GSL_EFAILED);
throw new InvalidOperationException("could not integrate function");
}
}
