using EasyRegression.Core;

...

// x is either double[][] or double?[][]
// y is double[]
// x will be preprocessed before training begins
double[][] x;
double[] y;

// Create a training data model from the x and y data
var trainingData = new TrainingModel<double>(x, y);

// Create an instance of the LinearRegressionEngine class with no parameters
var regressionEngine = new LinearRegressionEngine();

// Train the linear regression engine using real data
regressionEngine.Train(trainingData);

// Predict y0 value based on input x0 where x0 is double[] or double?[]
// x0 will be preprocessed before the prediction is made
double y0 = regressionEngine.Predict(x0);

// Create and train a linear regression engine as in the previous example
var regression = new LinearRegressionEngine();
regression.Train(trainingData);

// Store the trained regression parameters as json
string json = regressionEngine.Serialise();

// Create a new instance of the LinearRegressionEngine from the serialised json
var newRegressionEngine = LinearRegressionEngine.Deserialise(json);

// Predict y1 value base on input x1
// x1 will be preprocessed the same as x0 was before predicting
double y1 = newRegressionEngine.Predict(x1);

// Create a set of preprocessing plugins to configure the preprocessor
IDataPatcher medianPatcher = new MedianDataPatcher();
IDataFilter standardDeviationFilter = new StandardDeviationFilter();
IDataExpander polynomialExpander = new PolynomialDataExpander(order: 2);
IDataSmoother normaliser = new DataNormaliser();

// Create instance of the Preprocessor class
IPreprocessor preprocessor = new Preprocessor();
preprocessor.SetDataPatcher(medianPatcher);
preprocessor.SetDataFilter(standardDeviationFilter);
preprocessor.SetDataExpander(polynomialExpander);
preprocessor.SetDataSmoother(normalise);

// Create instance of LinearRegressionEngine and pass in the custom/configured preprocessor
var regression = new LinearRegressionEngine();
regression.SetPreprocessor(preprocessor);

// Create mean data patcher
IDataPatcher meanPatcher = new MeanDataPatcher();

// Create median data patcher
IDataPatcher medianPatcher = new MedianDataPatcher();

// Create zero data patcher
IDataPatcher zeroPatcher = new ZeroDataPatcher();

// Patch input data where data is either Matrix<double> or Matrix<double?>
Matrix<double> patchedData = meanPatcher.Patch(data);

// Pass a specific data patcher into a Preprocessor
IPreprocessor preprocessor = new Preprocessor();
preprocessor.SetDataPatcher(meanPatcher);

// Create std dev data filter
IDataFilter standardDeviationFilter = new StandardDeviationFilter();
// Set std dev multiple to 2.5 (default 3.0)
standardDeviationFilter.SetStandardDeviationMultiple(2.5);

// Create iqr data filter
IDataFilter interQuartileRangeFilter = new InterQuartileRangeFilter();
// Set iqr multiple to 2.0 (default 1.5)
interQuartileRangeFilter.SetInterQuartileRangeMultiple(2.0);

// Create mad data filter
IDataFilter medianAbsoluteFilter = new MedianAbsoluteDeviationFilter();
// Set mad multiple to 4.0 (default 4.5)
medianAbsoluteFilter.SetMedianDeviationMultiple(4.0);

// Create blank data filter
IDataFilter blankFilter = new BlankDataFilter();

// Create training model from Matrix<double> or double[][] x and double[] y
TrainingModel<double> trainingData = new TrainingModel(x, y);
// Filter input data where data is TrainingModel<double>
TrainingModel<double> filteredData = standardDeviationFilter.Filter(trainingData);

// Pass a specific data filter into a Preprocessor
IPreprocessor preprocessor = new Preprocessor();
preprocessor.SetDataFilter(standardDeviationFilter);

// Create polynomial product expander with polynomial order 1
// [x0, x1] => [1, x1, x0, x0x1]
IDataExpander polynomialProductExpander = new PolynomialProductDataExpander(order: 1);

// Create polynomial expander with order 2
// [x0, x1] => [1, x0, x0x0, x1, x1x1]
IDataExpander polynomialExpander = new PolynomialDataExpander(order: 2);

//Add custom function to function definitions
PreprocessingDefinitions.DataFunctions.Add("test", x => x + 2);
// Create function expander with custom function, sqrt, and log
// FunctionDataExpander takes an array of strings
// To see all available strings, look at PreprocessingDefinitions.DataFunctions.Keys
// [x0, x1] => [1, x0, x0+2, sqrt(x0), log(x0), x1, x1+2, sqrt(x1), log(x1)]
IDataExpander functionExpander = new FunctionDataExpander(new[] { "test", "sqrt", "log" });

// Create intercept expander
// [x0, x1] => [1, x0, x1]
IDataExpander interceptExpander = new InterceptDataExpander();

// Create blank expander
// [x0, x1] => [x0, x1]
IDataExpander blankExpander = new BlankDataExpander();

// Expand a Matrix<double> of data
// This expander creates huge amounts of data as data.Length and order increase
// Creates Math.Pow(order + 1, data.Length) features
Matrix<double> expandedData = polynomialExpander.Expand(data);

// Pass an expander into a preprocessor
IPreprocessor preprocessor = new Preprocessor();
preprocessor.SetDataExpander(polynomialExpander);

// Create data normaliser
// X := (x - min) / (max - min)
IDataSmoother normaliser = new DataNormaliser();

// Create data standardiser
// X := (x - 𝜎) / 𝜇
IDataSmoother standardiser = new DataStandardiser();

// Create blank data smoother
// X := x
IDataSmoother blankSmoother = new BlankDataSmoother();

// Smooth input data where data is Matrix<double>
Matrix<double> smoothedData = standardiser.Smooth(data);

// Pass a specific data smoother into a Preprocessor
IPreprocessor preprocessor = new Preprocessor();
preprocessor.SetDataSmoother(normaliser);