As can be seen the C++ application appears to be much faster than the C# application. Also, in my humble opinion, C++ with header files and C++ source code files is much more elegant than C# with only class source code. I leave it to someone else to add C# interfaces to my class source code files.
A few years ago, I implemented the Shanks-Mestre elliptic curve point counting algorithm in C# using the BigInteger data structure and the algorithm found in Henri Cohen’s textbook A Course in Computational Algebraic Number Theory. I translated the C# application to C++ in August 21-22, 2023. The C++ code uses the long long 64-bit signed integer data type. Below are some results. I also implemented Schoof’s point counting algorithm in C#.
The exclusive or (XOR) function is a very well known simple two input binary function in the world of computer architecture. The truth table has four rows with two input columns 00, 01, 10, and 11. The output column is 0, 1, 1, 0. In other words, the XOR function is false for like inputs and true for unlike inputs. This function is also known in the world of cryptography and is the encryption and decryption function for the stream cipher called the onetime pad. The onetime pad is perfectly secure as long as none of the pad is resused. The original artificial feedforward neural network was unable to correctly generate the outputs of the XOR function. This disadvantage was overcome by the addition of back-propagation to the artificial neural network. The outputs must be adjusted to 0.1 and 0.9 for the logistic also known as the sigmoid activation function to work.
using System;
using System.Windows.Forms;
namespace BPNNTestOne
{
public class BPNeuralNetwork
{
private static double RANGE = 0.1;
private double learningRate, momentum, tolerance;
private double[] deltaHidden, deltaOutput, h, o, p;
private double[,] newV, newW, oldV, oldW, v, w, O, T, X;
private int numberHiddenUnits, numberInputUnits;
private int numberOutputUnits, numberTrainingExamples;
private int maxEpoch;
private Random random;
private TextBox tb;
public double[] P
{
get
{
return p;
}
}
double random_range(double x_0, double x_1)
{
double temp;
if (x_0 > x_1)
{
temp = x_0;
x_0 = x_1;
x_1 = temp;
}
return (x_1 - x_0) * random.NextDouble() + x_0;
}
public BPNeuralNetwork
(
double alpha,
double eta,
double threshold,
int nHidden,
int nInput,
int nOutput,
int nTraining,
int nMaxEpoch,
int seed,
TextBox tbox
)
{
int i, j, k;
random = new Random(seed);
learningRate = eta;
momentum = alpha;
tolerance = threshold;
numberHiddenUnits = nHidden;
numberInputUnits = nInput;
numberOutputUnits = nOutput;
numberTrainingExamples = nTraining;
maxEpoch = nMaxEpoch;
tb = tbox;
h = new double[numberHiddenUnits + 1];
o = new double[numberOutputUnits + 1];
p = new double[numberOutputUnits + 1];
h[0] = 1.0;
deltaHidden = new double[numberHiddenUnits + 1];
deltaOutput = new double[numberOutputUnits + 1];
newV = new double[numberHiddenUnits + 1, numberOutputUnits + 1];
oldV = new double[numberHiddenUnits + 1, numberOutputUnits + 1];
v = new double[numberHiddenUnits + 1, numberOutputUnits + 1];
newW = new double[numberInputUnits + 1, numberHiddenUnits + 1];
oldW = new double[numberInputUnits + 1, numberHiddenUnits + 1];
w = new double[numberInputUnits + 1, numberHiddenUnits + 1];
for (j = 0; j <= numberHiddenUnits; j++)
{
for (k = 1; k <= numberOutputUnits; k++)
{
oldV[j, k] = random_range(-RANGE, +RANGE);
v[j, k] = random_range(-RANGE, +RANGE);
}
}
for (i = 0; i <= numberInputUnits; i++)
{
for (j = 0; j <= numberHiddenUnits; j++)
{
oldW[i, j] = random_range(-RANGE, +RANGE);
w[i, j] = random_range(-RANGE, +RANGE);
}
}
O = new double[numberTrainingExamples + 1, numberOutputUnits + 1];
T = new double[numberTrainingExamples + 1, numberInputUnits + 1];
X = new double[numberTrainingExamples + 1, numberInputUnits + 1];
}
public void SetTrainingExample(double[] t, double[] x, int d)
{
int i, k;
for (i = 0; i <= numberInputUnits; i++)
X[d, i] = x[i];
for (k = 0; k <= numberOutputUnits; k++)
T[d, k] = t[k];
}
private double f(double x)
// squashing function = a sigmoid function
{
return 1.0 / (1.0 + Math.Exp(-x));
}
private double g(double x)
// derivative of the squashing function
{
return f(x) * (1.0 - f(x));
}
public void ForwardPass(double[] x)
{
double sum;
int i, j, k;
for (j = 1; j <= numberHiddenUnits; j++)
{
for (i = 0, sum = 0; i <= numberInputUnits; i++)
sum += x[i] * w[i, j];
h[j] = sum;
}
for (k = 1; k <= numberOutputUnits; k++)
{
for (j = 1, sum = h[0] * v[0, k]; j <= numberHiddenUnits; j++)
sum += f(h[j]) * v[j, k];
o[k] = sum;
p[k] = f(o[k]);
}
}
private void BackwardPass(double[] t, double[] x)
{
double sum;
int i, j, k;
for (k = 1; k <= numberOutputUnits; k++)
deltaOutput[k] = (p[k] * (1 - p[k])) * (t[k] - p[k]);
for (k = 1; k <= numberOutputUnits; k++)
{
newV[0, k] = learningRate * h[0] * deltaOutput[k];
for (j = 1; j <= numberHiddenUnits; j++)
newV[j, k] = learningRate * f(h[j]) * deltaOutput[k];
for (j = 0; j <= numberHiddenUnits; j++)
{
v[j, k] += newV[j, k] + momentum * oldV[j, k];
oldV[j, k] = newV[j, k];
}
}
for (j = 1; j <= numberHiddenUnits; j++)
{
for (k = 1, sum = 0; k <= numberOutputUnits; k++)
sum += v[j, k] * deltaOutput[k];
deltaHidden[j] = g(h[j]) * sum;
for (i = 0; i <= numberInputUnits; i++)
{
newW[i, j] = learningRate * x[i] * deltaHidden[j];
w[i, j] += newW[i, j] + momentum * oldW[i, j];
oldW[i, j] = newW[i, j];
}
}
}
public double[,] Backpropagation(bool intermediate, int number)
{
double error = double.MaxValue;
int d, k, epoch = 0;
while (epoch < maxEpoch && error > tolerance)
{
error = 0.0;
for (d = 1; d <= numberTrainingExamples; d++)
{
double[] x = new double[numberInputUnits + 1];
for (int i = 0; i <= numberInputUnits; i++)
x[i] = X[d, i];
ForwardPass(x);
double[] t = new double[numberOutputUnits + 1];
for (int i = 0; i <= numberOutputUnits; i++)
t[i] = T[d, i];
BackwardPass(t, x);
for (k = 1; k <= numberOutputUnits; k++)
{
O[d, k] = p[k];
error += Math.Pow(T[d, k] - O[d, k], 2);
}
}
epoch++;
error /= (numberTrainingExamples * numberOutputUnits);
if (intermediate && epoch % number == 0)
tb.Text += error.ToString("E10") + "\r\n";
}
tb.Text += "\r\n";
tb.Text += "Mean Square Error = " + error.ToString("E10") + "\r\n";
tb.Text += "Epoch = " + epoch + "\r\n";
return O;
}
}
}
// Learn the XOR Function
// Inputs/Targets
// 0 0 / 0
// 0 1 / 1
// 1 0 / 1
// 1 1 / 0
// The logistic function works
// with 0 -> 0.1 and 1 -> 0.9
//
// BPNNTestOne (c) 2011
// James Pate Williams, Jr.
// All rights reserved.
using System;
using System.Windows.Forms;
namespace BPNNTestOne
{
public partial class MainForm : Form
{
private int seed = 512;
private BPNeuralNetwork bpnn;
public MainForm()
{
InitializeComponent();
int numberInputUnits = 2;
int numberOutputUnits = 1;
int numberHiddenUnits = 2;
int numberTrainingExamples = 4;
double[,] X =
{
{1.0, 0.0, 0.0},
{1.0, 0.0, 0.0},
{1.0, 0.0, 1.0},
{1.0, 1.0, 0.0},
{1.0, 1.0, 1.0}
};
double[,] T =
{
{1.0, 0.0},
{1.0, 0.1},
{1.0, 0.9},
{1.0, 0.9},
{1.0, 0.1}
};
bpnn = new BPNeuralNetwork(0.1, 0.9, 1.0e-12,
numberHiddenUnits, numberInputUnits,
numberOutputUnits, numberTrainingExamples,
5000, seed, textBox1);
for (int i = 1; i <= numberTrainingExamples; i++)
{
double[] x = new double[numberInputUnits + 1];
double[] t = new double[numberOutputUnits + 1];
for (int j = 0; j <= numberInputUnits; j++)
x[j] = X[i, j];
for (int j = 0; j <= numberOutputUnits; j++)
t[j] = T[i, j];
bpnn.SetTrainingExample(t, x, i);
}
double[,] O = bpnn.Backpropagation(true, 500);
textBox1.Text += "\r\n";
textBox1.Text += "x0\tx1\tTarget\tOutput\r\n\r\n";
for (int i = 1; i <= numberTrainingExamples; i++)
{
for (int j = 1; j <= numberInputUnits; j++)
textBox1.Text += X[i, j].ToString("##0.#####") + "\t";
for (int j = 1; j <= numberOutputUnits; j++)
{
textBox1.Text += T[i, j].ToString("####0.#####") + "\t";
textBox1.Text += O[i, j].ToString("####0.#####") + "\t";
}
textBox1.Text += "\r\n";
}
}
}
}
Below are three screenshots of two methods of calculating the determinant of a matrix, namely the Bareiss Algorithm and Gaussian Elimination:
using System;
using System.Diagnostics;
using System.Windows.Forms;
namespace MatrixInverseComparison
{
public partial class MainForm : Form
{
public MainForm()
{
InitializeComponent();
}
static private string FormatNumber(double x)
{
string result = string.Empty;
if (x > 0)
result += x.ToString("F5").PadLeft(10);
else
result += x.ToString("F5").PadLeft(10);
return result;
}
private void MultiplyPrintMatricies(
double[,] A, double[,] B, int n)
{
double[,] I = new double[n, n];
textBox1.Text += "Matrix Product:\r\n";
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
double sum = 0.0;
for (int k = 0; k < n; k++)
sum += A[i, k] * B[k, j];
I[i, j] = sum;
}
}
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
textBox1.Text += FormatNumber(I[i, j]) + " ";
}
textBox1.Text += "\r\n";
}
}
private void PrintMatrix(string title, double[,] A, int n)
{
textBox1.Text += title + "\r\n";
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
textBox1.Text += FormatNumber(A[i, j]) + " ";
}
textBox1.Text += "\r\n";
}
}
private void Compute(double[,] MI, int n)
{
double determinantGE = 1;
double[] b = new double[n];
double[] x = new double[n];
double[,] MB1 = new double[n, n];
double[,] MB2 = new double[n, n];
double[,] MG = new double[n, n];
double[,] MS = new double[n, n];
double[,] IG = new double[n, n];
double[,] IS = new double[n, n];
int[] pivot = new int[n];
Stopwatch sw = new();
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
MB1[i, j] = MB2[i, j] = MG[i, j] = MS[i, j] = MI[i, j];
}
PrintMatrix("Initial Matrix: ", MI, n);
sw.Start();
int flag = DirectMethods.Factor(MG, n, pivot);
if (flag != 0)
{
for (int i = 0; i < n; i++)
determinantGE *= MG[i, i];
determinantGE *= flag;
}
sw.Stop();
PrintMatrix("Gaussian Elimination Final:", MG, n);
for (int i = 0; i < n; i++)
b[i] = 0;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
b[j] = 1.0;
DirectMethods.Substitute(MG, b, x, n, pivot);
for (int k = 0; k < n; k++)
IG[k, j] = x[k];
b[j] = 0.0;
}
}
PrintMatrix("Gaussian Elimination Inverse:", IG, n);
textBox1.Text += "Determinant: " +
FormatNumber(determinantGE) + "\r\n";
MultiplyPrintMatricies(IG, MI, n);
textBox1.Text += "Runtime (MS) = " +
sw.ElapsedMilliseconds + "\r\n";
sw.Start();
double determinant1 = BareissAlgorithm.Determinant1(MB1, n);
sw.Stop();
PrintMatrix("Bareiss Algorithm Final 1:", MB1, n);
textBox1.Text += "Determinant: " +
FormatNumber(determinant1) + "\r\n";
textBox1.Text += "Runtime (MS) = " +
sw.ElapsedMilliseconds + "\r\n";
sw.Start();
double determinant2 = BareissAlgorithm.Determinant2(MB2, n);
sw.Stop();
PrintMatrix("Bareiss Algorithm Final 2:", MB2, n);
textBox1.Text += "Determinant: " +
FormatNumber(determinant2) + "\r\n";
textBox1.Text += "Runtime (MS) = " +
sw.ElapsedMilliseconds + "\r\n";
}
private void button1_Click(object sender, EventArgs e)
{
int n = (int)numericUpDown1.Value;
int seed = (int)numericUpDown2.Value;
double[,] A = new double[n, n];
Random random = new Random(seed);
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
double q = n * random.NextDouble();
while (q == 0.0)
q = n * random.NextDouble();
A[i, j] = q;
}
}
Compute(A, n);
}
private void button2_Click(object sender, EventArgs e)
{
textBox1.Text = string.Empty;
}
}
}
using System;
namespace MatrixInverseComparison
{
public class DirectMethods
{
// Substitute and Factor translated from FORTRAN 77
// source code found in "Elementary Numerical Analysis:
// An Algorithmic Approach" by S. D. Conte and Carl de
// Boor. Translator: James Pate Williams, Jr. (c)
// August 14 - 17, 2023
static public void Substitute(
double[,] w,
double[] b,
double[] x,
int n,
int[] pivot)
{
double sum;
int i, j, n1 = n - 1;
if (n == 1)
{
x[0] = b[0] / w[0, 0];
return;
}
// forward substitution
x[0] = b[pivot[0]];
for (i = 0; i < n; i++)
{
for (j = 0, sum = 0.0; j < i; j++)
sum += w[i, j] * x[j];
x[i] = b[pivot[i]] - sum;
}
// backward substitution
x[n1] /= w[n1, n1];
for (i = n - 2; i >= 0; i--)
{
for (j = i + 1, sum = 0.0; j < n; j++)
sum += w[i, j] * x[j];
x[i] = (x[i] - sum) / w[i, i];
}
}
// Factor returns +1 if an even number of exchanges
// Factor returns -1 if an odd number of exchanges
// Factor retrurn 0 if matrix is singular
static public int Factor(
double[,] w, int n, int[] pivot)
// returns 0 if matrix is singular
{
double awikod, col_max, ratio, row_max, temp;
double[] d = new double[n];
int flag = 1, i, i_star, j, k;
for (i = 0; i < n; i++)
{
pivot[i] = i;
row_max = 0;
for (j = 0; j < n; j++)
row_max = Math.Max(row_max, Math.Abs(w[i, j]));
if (row_max == 0)
{
flag = 0;
row_max = 1;
}
d[i] = row_max;
}
if (n <= 1)
return flag;
// factorization
for (k = 0; k < n - 1; k++)
{
// determine pivot row the row i_star
col_max = Math.Abs(w[k, k]) / d[k];
i_star = k;
for (i = k + 1; i < n; i++)
{
awikod = Math.Abs(w[i, k]) / d[i];
if (awikod > col_max)
{
col_max = awikod;
i_star = i;
}
}
if (col_max == 0)
flag = 0;
else
{
if (i_star > k)
{
// make k the pivot row by
// interchanging with i_star
flag *= -1;
i = pivot[i_star];
pivot[i_star] = pivot[k];
pivot[k] = i;
temp = d[i_star];
d[i_star] = d[k];
d[k] = temp;
for (j = 0; j < n; j++)
{
temp = w[i_star, j];
w[i_star, j] = w[k, j];
w[k, j] = temp;
}
}
// eliminate x[k]
for (i = k + 1; i < n; i++)
{
w[i, k] /= w[k, k];
ratio = w[i, k];
for (j = k + 1; j < n; j++)
w[i, j] -= ratio * w[k, j];
}
}
}
if (w[n - 1, n - 1] == 0)
flag = 0;
return flag;
}
}
}
namespace MatrixInverseComparison
{
// One implementation is based on https://en.wikipedia.org/wiki/Bareiss_algorithm
// Another perhaps better implementation is found on the following webpage
// https://cs.stackexchange.com/questions/124759/determinant-calculation-bareiss-vs-gauss-algorithm
class BareissAlgorithm
{
static public double Determinant1(double[,] M, int n)
{
double M00;
for (int k = 0; k < n; k++)
{
if (k - 1 == -1)
M00 = 1;
else
M00 = M[k - 1, k - 1];
for (int i = k + 1; i < n; i++)
{
for (int j = k + 1; j < n; j++)
{
M[i, j] = (
M[i, j] * M[k, k] -
M[i, k] * M[k, j]) / M00;
}
}
}
return M[n - 1, n - 1];
}
static public double Determinant2(double[,] A, int dim)
{
if (dim <= 0)
{
return 0;
}
double sign = 1;
for (int k = 0; k < dim - 1; k++)
{
//Pivot - row swap needed
if (A[k, k] == 0)
{
int m;
for (m = k + 1; m < dim; m++)
{
if (A[m, k] != 0)
{
double[] tempRow = new double[dim];
for (int i = 0; i < dim; i++)
tempRow[i] = A[m, i];
for (int i = 0; i < dim; i++)
A[m, i] = A[k, i];
for (int i = 0; i < dim; i++)
A[k, i] = tempRow[i];
sign = -sign;
break;
}
}
//No entries != 0 found in column k -> det = 0
if (m == dim)
{
return 0;
}
}
//Apply formula
for (int i = k + 1; i < dim; i++)
{
for (int j = k + 1; j < dim; j++)
{
A[i, j] = A[k, k] * A[i, j] - A[i, k] * A[k, j];
if (k >= 1)
{
A[i, j] /= A[k - 1, k - 1];
}
}
}
}
return sign * A[dim - 1, dim - 1];
}
}
}
Numerical Explorations 