//------------- constructors -----------// public PerceptronNew( IAlgebraLinear <MatrixType> algebra, int input_dimensions, int output_dimensions, IFunction <double, double> output_function, IFunction <double, double> output_function_derivative) { d_random = new RNGCryptoServiceProvider(); d_algebra = algebra; d_output_function = output_function; d_output_function_derivative = output_function_derivative; layerNumber = nLayers++; //useful for debugging purposes d_input_size = input_dimensions + 1; //input + bias d_output_size = output_dimensions; d_weights = d_algebra.CreateZeros(d_input_size, d_output_size); d_batch_weights = d_algebra.CreateZeros(d_input_size, d_output_size); d_eligibility_traces = d_algebra.CreateZeros(d_input_size, d_output_size); d_input = d_algebra.CreateZeros(1, d_input_size); input_error = d_algebra.CreateZeros(1, d_input_size); d_activation = d_algebra.CreateZeros(1, d_output_size); activation_error = d_algebra.CreateZeros(1, d_output_size); d_output = d_algebra.CreateZeros(1, d_output_size); d_output_error = d_algebra.CreateZeros(1, d_output_size); ClearInputMatrix(); }
// // ------------- constructors -----------// public MultiLayerPerceptronNew( IAlgebraLinear <DataType> algebra, int [] setup, IFunction <double, double> output_function, IFunction <double, double> output_function_derivative, double learning_rate, double eligibility) { d_algebra = algebra; d_random = new RNGCryptoServiceProvider(); d_learning_rate = learning_rate; d_eligibility = eligibility; Perceptron.nLayers = 0; this.d_setup = setup; d_layer_count = setup.Length - 1; // nr of learnable layers, no input layer d_layers = new PerceptronNew <DataType> [d_layer_count]; // hidden + output layers: for (int l = 0; l < d_layer_count; ++l) { int nInput = setup[l]; // input size = previous layers output size int nOutput = setup[l + 1]; // output size = nr of neurons in this layer d_layers[l] = new PerceptronNew <DataType>(d_algebra, nInput, nOutput, output_function, output_function_derivative); } }
public DeconvolutionSVD(IAlgebraLinear <MatrixType> algebra, IFunction <double, double> input_function, double[] signal_sample_times) { // build AIF matrix AMatrix <MatrixType> forward_matrix = null; SVD <MatrixType> svd = algebra.ComputeSVD(forward_matrix); }
public TransformWhiteningOld(IAlgebraLinear <MatrixType> algebra, float [,] data) { AMatrix <MatrixType> data_matrix = algebra.Create(data); means = algebra.Create(ToolsMathStatistics.Means1(data)); AMatrix <MatrixType> covariance_matrix = data_matrix * data_matrix.Transpose(); matrix_backward = covariance_matrix.Algebra.ComputeRoot(covariance_matrix); matrix_forward = matrix_backward.Invert(); }
public static void TestMultiplyScalar <MatrixType>(IAlgebraLinear <MatrixType> algebra) { AMatrix <MatrixType> A = algebra.Create(new double[, ] { { 1, 2 }, { 3, 4 } }); AMatrix <MatrixType> C = A * 2; Assert.AreEqual(2, C.GetElement(0, 0)); Assert.AreEqual(4, C.GetElement(0, 1)); Assert.AreEqual(6, C.GetElement(1, 0)); Assert.AreEqual(8, C.GetElement(1, 1)); }
public static void TestAddOne <MatrixType>(IAlgebraLinear <MatrixType> algebra) { AMatrix <MatrixType> A = algebra.Create(new double[, ] { { 1, 2 }, { 3, 4 } }); AMatrix <MatrixType> B = A + 1; Assert.AreEqual(2, B.GetElement(0, 0)); Assert.AreEqual(3, B.GetElement(0, 1)); Assert.AreEqual(4, B.GetElement(1, 0)); Assert.AreEqual(5, B.GetElement(1, 1)); }
public static void TestMatrixMatrixProduct0 <MatrixType>(IAlgebraLinear <MatrixType> algebra) { AMatrix <MatrixType> A = algebra.Create(new double[, ] { { 1, 0 }, { 0, 1 } }); AMatrix <MatrixType> B = algebra.Create(new double[, ] { { 1, 2 }, { 3, 4 } }); AMatrix <MatrixType> C = A * B; Assert.AreEqual(1, C.GetElement(0, 0)); Assert.AreEqual(2, C.GetElement(0, 1)); Assert.AreEqual(3, C.GetElement(1, 0)); Assert.AreEqual(4, C.GetElement(1, 1)); }
//AMatrix<MatrixType> forward_matrix_flipped; public DeconvolutionRichardsonLucy(IAlgebraLinear <MatrixType> algebra, ITemplateBasisFunction template, IFunction <double, double> input_function, double[] signal_sample_times) { this.algebra = algebra; this.basis_function_list = new List <IFunction <double, double> >(); double[,] forward_array = new double[signal_sample_times.Length, signal_sample_times.Length]; for (int column_index = 0; column_index < signal_sample_times.Length; column_index++) { IFunction <double, double> basis_function = template.Generate(input_function, signal_sample_times, column_index); basis_function_list.Add(basis_function); for (int row_index = 0; row_index < signal_sample_times.Length; row_index++) { forward_array[row_index, column_index] = basis_function.Compute(signal_sample_times[row_index]); } } forward_matrix = algebra.Create(forward_array); }
public RendererPoints(IAlgebraLinear <MatrixType> algebra, int bitmap_size_x, int bitmap_size_y, AngleRadian pitch, AngleRadian yaw, double[] offset, double scale) { this.bitmap_size_x = bitmap_size_x; this.bitmap_size_y = bitmap_size_y; this.scale = scale; this.offset_matrix = algebra.Create(offset); //float [] vector_view = new float[3]; // unit vector in the direction we view, 0,0 is from the top the regular way, should produce [0 0 0] //(0,0 should procux x = [1 0 0], y = [0 1 0]) //isometric projection //http://www.wolframalpha.com/input/?i=%7B%7B1%2C+0+%2C0%7D%2C%7B0%2C+cos%28a%29%2C+sin%28a%29%7D%2C%7B0%2C+-sin%28a%29%2C+cos%28a%29%7D%7D.%7B%7Bcos%28b%29%2C+0%2C+-sin%28b%29%7D%2C%7B0%2C1%2C0%7D%2C%7Bsin%28b%29%2C+0+%2C+cos%28b%29%7D%7D double a = (double)pitch; double b = (double)yaw; double[,] projection_array = new double[, ] { { Math.Cos(b), Math.Sin(a) * Math.Sin(b), Math.Cos(a) * Math.Sin(b) }, { 0, Math.Cos(a), -Math.Sin(a) }, { -Math.Sin(b), Math.Sin(a) * Math.Cos(b), Math.Cos(a) * Math.Cos(b) } }; projection_matrix = algebra.Create(projection_array); }
public RendererPoints(IAlgebraLinear <MatrixType> algebra, int bitmap_size_x, int bitmap_size_y, AngleRadian pitch, AngleRadian yaw, double scale) : this(algebra, bitmap_size_x, bitmap_size_y, yaw, pitch, new double[] { 0, 0, 0 }, scale) { }
public SolverLinearGMRES(IAlgebraLinear <MatrixDataType> algebra) { this.algebra = algebra; this.simple_solver = algebra.GetSimpleSolver(); }
public TemplateDimensionReductionPCA(IAlgebraLinear <MatrixType> algebra, int destination_dimension_count) { this.algebra = algebra; this.destination_dimension_count = destination_dimension_count; }
public DimensionReductionPCA(IDataContext data_context, AMatrix <MatrixType> projection) { this.DataContext = data_context; this.algebra = projection.Algebra; this.projection = projection; }
protected AMatrix(IAlgebraLinear <DataType> algebra, DataType data) { this.Algebra = algebra; this.Data = data; }
public MatrixKozzion(IAlgebraLinear <DataType [, ]> algebra, DataType[,] data, bool transpose = false) : base(algebra, data) { this.transpose = transpose; }