Updates for machine
This commit is contained in:
znetsixe
593
src/predict/predict_class.js
Normal file
593
src/predict/predict_class.js
Normal file
@@ -0,0 +1,593 @@
|
||||
/**
|
||||
* @file Predict_class.js
|
||||
*
|
||||
* Permission is hereby granted to any person obtaining a copy of this software
|
||||
* and associated documentation files (the "Software"), to use it for personal
|
||||
* or non-commercial purposes, with the following restrictions:
|
||||
*
|
||||
* 1. **No Copying or Redistribution**: The Software or any of its parts may not
|
||||
* be copied, merged, distributed, sublicensed, or sold without explicit
|
||||
* prior written permission from the author.
|
||||
*
|
||||
* 2. **Commercial Use**: Any use of the Software for commercial purposes requires
|
||||
* a valid license, obtainable only with the explicit consent of the author.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
* SOFTWARE.
|
||||
*
|
||||
* Ownership of this code remains solely with the original author. Unauthorized
|
||||
* use of this Software is strictly prohibited.
|
||||
*
|
||||
* @summary Class for predicting values based on a multidimensional curve.
|
||||
* @description Class for predicting values based on a multidimensional curve.
|
||||
* @module Predict_class
|
||||
* @requires EventEmitter
|
||||
* @requires ConfigUtils
|
||||
* @requires Interpolation
|
||||
* @requires Logger
|
||||
* @exports Predict
|
||||
* @version 0.1.0
|
||||
* @since 0.1.0
|
||||
*
|
||||
* Author:
|
||||
* - Rene De Ren
|
||||
* Email:
|
||||
* - rene@thegoldenbasket.nl
|
||||
* Future Improvements:
|
||||
- Add more interpolation types
|
||||
- **Local Derivative (Slope)**: Instantaneous rate of change (dY/dX) at the current X. Useful for determining if the curve is ascending or descending.
|
||||
- **Second Derivative (Curvature)**: Curvature (d²Y/dX²) at the current X. Indicates how quickly the slope is changing (e.g., sharp or broad peaks).
|
||||
- **Distance to Nearest Local Peak or Valley**: X-distance from the current X to the closest local maximum or minimum. Useful for detecting proximity to turning points.
|
||||
- **Global Statistics (Mean, Median, Std Dev)**:
|
||||
- Mean: Average of Y.
|
||||
- Median: Middle Y value (sorted).
|
||||
- Std Dev: Variability of Y. Provides insight into central tendency and spread, aiding in normalization or anomaly detection.
|
||||
- **Integrated Area Under the Curve (AUC)**: Numerical integration of Y across the X-range. Useful for total sums or energy-related calculations.
|
||||
- **Peak “Sharpness” or “Prominence”**: Measure of a peak's height and width relative to surrounding valleys. Important for signal processing or optimization.
|
||||
- **Nearest Points Around Current X**: Data points (or interpolated values) immediately to the left and right of the current X. Useful for local interpolation or neighbor analysis.
|
||||
- **Forecast / Extrapolation**: Estimated Y values outside the known X-range. Useful for exploring scenarios slightly beyond the data range (use with caution).
|
||||
- **Peak Count**: Total number of local maxima in the curve. Useful for identifying all peaks and their prominence.
|
||||
- **Position Relative to Mean (or Other Reference Lines)**: Distance (in percent or absolute value) of the current Y from a reference line (e.g., mean or median). Provides context relative to average or baseline levels.
|
||||
- **Local Slope Trend**: Direction of the slope (up, down, or flat) at the current X. Useful for identifying trends or inflection points.
|
||||
- **Local Curvature Trend**: Direction of the curvature (concave up, concave down, or flat) at the current X. Useful for identifying inflection points or turning points.
|
||||
- **Local Peak-to-Valley Ratio**: Ratio of the current peak height to the nearest valley depth. Useful for identifying peak prominence or sharpness.
|
||||
- ** Keep track of previous request and next request to identify slope and curvature
|
||||
*/
|
||||
|
||||
const EventEmitter = require('events');
|
||||
const Logger = require('../helper/logger.js');
|
||||
const defaultConfig = require('./predictConfig.json');
|
||||
const ConfigUtils = require('../helper/configUtils');
|
||||
const Interpolation = require('./interpolation');
|
||||
|
||||
class Predict {
|
||||
constructor(config = {}) {
|
||||
|
||||
// Initialize dependencies
|
||||
this.emitter = new EventEmitter(); // Own EventEmitter
|
||||
this.configUtils = new ConfigUtils(defaultConfig);
|
||||
this.config = this.configUtils.initConfig(config);
|
||||
|
||||
// Init after config is set
|
||||
this.logger = new Logger(this.config.general.logging.enabled,this.config.general.logging.logLevel, this.config.general.name);
|
||||
this.interpolation = new Interpolation(this.config.interpolation);
|
||||
|
||||
// Input and state
|
||||
this.inputCurve = {};
|
||||
this.currentF = 0;
|
||||
this.currentX = 0;
|
||||
this.outputY = 0;
|
||||
|
||||
// Curves and Splines
|
||||
this.normalizedCurve = {};
|
||||
this.calculatedCurve = {};
|
||||
this.fCurve = {};
|
||||
this.currentFxyCurve = {};
|
||||
this.normalizedSplines = {};
|
||||
this.fSplines = {};
|
||||
this.currentFxySplines = {};
|
||||
|
||||
// Stored min/max values
|
||||
this.xValues = {};
|
||||
this.fValues = {};
|
||||
this.yValues = {};
|
||||
this.currentFxyXMin = 0;
|
||||
this.currentFxyXMax = 0;
|
||||
this.currentFxyYMin = 0;
|
||||
this.currentFxyYMax = 0;
|
||||
|
||||
// From config
|
||||
this.normMin = this.config.normalization.parameters.min;
|
||||
this.normMax = this.config.normalization.parameters.max;
|
||||
this.calculationPoints = this.config.normalization.parameters.curvePoints;
|
||||
this.interpolationType = this.config.interpolation.type;
|
||||
|
||||
// Load curve if provided
|
||||
if (config.curve) {
|
||||
this.inputCurveData = config.curve;
|
||||
} else {
|
||||
this.logger.warn("No curve data provided. Please set curve data using setCurveData method. Using default");
|
||||
this.inputCurveData = this.config.curve;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Improved function to get a local peak in an array by starting in the middle.
|
||||
// It also handles the case of a tie by preferring the left side (arbitrary choice)
|
||||
// when array[start] == leftValue or array[start] == rightValue.
|
||||
getLocalPeak(array) {
|
||||
if (!Array.isArray(array) || array.length === 0) {
|
||||
return { peak: null, peakIndex: -1 };
|
||||
}
|
||||
|
||||
let left = 0;
|
||||
let right = array.length - 1;
|
||||
|
||||
while (left <= right) {
|
||||
const mid = Math.floor((left + right) / 2);
|
||||
|
||||
// Safely retrieve left/right neighbor values (use -Infinity if out of bounds)
|
||||
const leftVal = mid - 1 >= 0 ? array[mid - 1] : -Infinity;
|
||||
const rightVal = mid + 1 < array.length ? array[mid + 1] : -Infinity;
|
||||
const currentVal = array[mid];
|
||||
|
||||
// Check if mid is a local peak
|
||||
if (currentVal >= leftVal && currentVal >= rightVal) {
|
||||
return { peak: currentVal, peakIndex: mid };
|
||||
}
|
||||
|
||||
// If left neighbor is bigger, move left
|
||||
if (leftVal > currentVal) {
|
||||
right = mid - 1;
|
||||
}
|
||||
// Otherwise, move right
|
||||
else {
|
||||
left = mid + 1;
|
||||
}
|
||||
}
|
||||
|
||||
// If no local peak is found
|
||||
return { peak: null, peakIndex: -1 };
|
||||
}
|
||||
|
||||
// Function what uses the peak in the y array to return the yPeak, x value and its procentual value
|
||||
getPosXofYpeak(curve) {
|
||||
|
||||
//find index of y peak
|
||||
const { peak , peakIndex } = this.getLocalPeak(curve.y);
|
||||
|
||||
// scale the x value to procentual value
|
||||
const yPeak = peak;
|
||||
const x = curve.x[peakIndex];
|
||||
const xMin = Math.min(...curve.x);
|
||||
const xMax = Math.max(...curve.x);
|
||||
const xProcent = (x - xMin) / (xMax - xMin) * 100;
|
||||
|
||||
return { yPeak, x, xProcent };
|
||||
}
|
||||
|
||||
calcRelativePositionToPeak(curve , outputY) {
|
||||
|
||||
//find y peak
|
||||
const { peak } = this.getLocalPeak(curve.y);
|
||||
|
||||
if ( peak === null ) {
|
||||
this.logger.warn("No peak found in curve");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Calculate the "peak-only" percentage:
|
||||
// - Distance from peak, relative to peak itself
|
||||
// - 0% => outputY == peak, 100% => outputY == 0 (if peak != 0)
|
||||
let peakOnlyPercentage;
|
||||
const distanceFromPeak = Math.abs(peak - outputY);
|
||||
if (peak === 0) {
|
||||
// If peak is 0, then the concept of "peak-only" percentage is tricky.
|
||||
// If outputY is also 0 => 0%, otherwise => Infinity.
|
||||
peakOnlyPercentage = distanceFromPeak === 0 ? 0 : Number.POSITIVE_INFINITY;
|
||||
} else {
|
||||
peakOnlyPercentage = (distanceFromPeak / peak) * 100;
|
||||
}
|
||||
|
||||
// Calculate the range-based percentage:
|
||||
// - Range = [yMin, peak]
|
||||
// - 0% => outputY == peak, 100% => outputY == yMin
|
||||
const yMin = Math.min(...curve.y);
|
||||
let rangeBasedPercentage = -1;
|
||||
|
||||
// If peak <= yMin, there is no vertical range for normalization
|
||||
if (peak > yMin) {
|
||||
const distanceFromPeakRange = peak - outputY; // Not absolute
|
||||
const totalRange = peak - yMin;
|
||||
rangeBasedPercentage = (distanceFromPeakRange / totalRange) * 100;
|
||||
|
||||
// Optionally clamp to [0, 100] if outputY goes out of bounds
|
||||
rangeBasedPercentage = Math.max(0, Math.min(100, rangeBasedPercentage));
|
||||
}
|
||||
|
||||
return {
|
||||
peakOnlyPercentage: Math.round(peakOnlyPercentage * 100) / 100,
|
||||
rangeBasedPercentage: Math.round(rangeBasedPercentage * 100) / 100
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
// Function to retrieve current curve including the interpolated active point
|
||||
retrieveActiveCurve(){
|
||||
|
||||
// Retreive y values
|
||||
const yValues = this.currentFxyCurve[this.fDimension].y;
|
||||
// Retreive normalized x values
|
||||
const xValues = this.denormalizeXvals( this.currentFxyCurve[this.fDimension].x );
|
||||
|
||||
//check what the current x value is
|
||||
const currentX = this.currentX;
|
||||
|
||||
//check current y Output value
|
||||
const outputY = this.outputY;
|
||||
|
||||
//find where the current x value should be in the xValues array
|
||||
const index = xValues.findIndex((x) => x > currentX);
|
||||
|
||||
// push the yOutput value in the yValues array between the current x value
|
||||
yValues.splice(index, 0, outputY);
|
||||
xValues.splice(index, 0, currentX);
|
||||
|
||||
return { xValues, yValues };
|
||||
}
|
||||
|
||||
set fDimension(newF) {
|
||||
|
||||
if (newF < this.fValues.min || newF > this.fValues.max) {
|
||||
this.logger.warn(`New f =${newF} is constrained to fit between min=${this.fValues.min} and max=${this.fValues.max}`);
|
||||
newF = this.constrain(newF,this.fValues.min,this.fValues.max);
|
||||
}
|
||||
|
||||
if (newF in this.calculatedCurve) {
|
||||
this.currentFxyCurve[newF] = this.calculatedCurve[newF];
|
||||
this.currentFxySplines = this.normalizedSplines;
|
||||
} else {
|
||||
this.currentFxyCurve = this.buildSingleFxyCurve(
|
||||
this.fSplines,
|
||||
this.calculatedCurve,
|
||||
newF,
|
||||
this.calculationPoints
|
||||
);
|
||||
this.currentFxySplines = this.buildXySplines(this.currentFxyCurve, this.interpolationType);
|
||||
}
|
||||
|
||||
const yArray = this.currentFxyCurve[newF].y;
|
||||
this.currentFxyYMin = Math.min(...yArray);
|
||||
this.currentFxyYMax = Math.max(...yArray);
|
||||
|
||||
this.calculateFxyXRange(newF);
|
||||
|
||||
this.currentF = newF;
|
||||
this.logger.debug(`Calculating new yValue using X= ${this.currentX}`);
|
||||
|
||||
// Recalculate output y based on currentX
|
||||
this.y(this.currentX);
|
||||
|
||||
}
|
||||
|
||||
get fDimension() {
|
||||
return this.currentF;
|
||||
}
|
||||
|
||||
// Function to predict Y value based on X value
|
||||
y(x) {
|
||||
|
||||
// Clamp value before normalization
|
||||
if (x > this.currentFxyXMax) x = this.currentFxyXMax;
|
||||
if (x < this.currentFxyXMin) x = this.currentFxyXMin;
|
||||
|
||||
//keep track of current x value
|
||||
this.currentX = x;
|
||||
|
||||
this.logger.debug(`Interpolating x using input=${x} , currentFxyXmin=${this.currentFxyXMin}, currentFxyXMax=${this.currentFxyXMax}, normMin=${this.normMin}, normMax=${this.normMax} `);
|
||||
|
||||
const normalizedX = this.interpolation.interpolate_lin_single_point(
|
||||
x,
|
||||
this.currentFxyXMin,
|
||||
this.currentFxyXMax,
|
||||
this.normMin,
|
||||
this.normMax
|
||||
);
|
||||
|
||||
this.logger.debug(`Calculating new Y value using ${normalizedX}`);
|
||||
|
||||
this.outputY = this.currentFxySplines[this.fDimension].interpolate(normalizedX);
|
||||
|
||||
return this.outputY;
|
||||
|
||||
}
|
||||
|
||||
set yOutput(y) {
|
||||
this.outputY = y;
|
||||
//by emitting this one output we dont have to use the entire class
|
||||
this.emitter.emit('yOutput', this.outputY);
|
||||
}
|
||||
|
||||
get yOutput() {
|
||||
return this.outputY;
|
||||
}
|
||||
|
||||
set inputCurveData(curve) {
|
||||
try {
|
||||
this.inputCurve = curve;
|
||||
this.buildAllFxyCurves(curve);
|
||||
} catch (error) {
|
||||
this.logger.error(`Curve validation failed: ${error.message}`);
|
||||
this.inputCurve = null; // Reset curve data if validation fails
|
||||
}
|
||||
}
|
||||
|
||||
get inputCurveData() {
|
||||
return this.inputCurve;
|
||||
}
|
||||
|
||||
updateCurve(curve) {
|
||||
|
||||
this.logger.info("Updating curve data");
|
||||
// update config with new curve data merged with existing config
|
||||
const newConfig = {...this.config, curve: curve};
|
||||
this.config = this.configUtils.updateConfig(newConfig);
|
||||
|
||||
const validatedCurve = this.config.curve;
|
||||
this.inputCurve = validatedCurve;
|
||||
|
||||
this.buildAllFxyCurves(validatedCurve);
|
||||
|
||||
}
|
||||
|
||||
constrain(value,min,max) {
|
||||
return Math.min(Math.max(value, min), max);
|
||||
}
|
||||
|
||||
buildAllFxyCurves(curve) {
|
||||
let globalMinY = Infinity;
|
||||
let globalMaxY = -Infinity;
|
||||
|
||||
for (const fKey of Object.keys(curve)) {
|
||||
const f = Number(fKey);
|
||||
this.xValues[f] = {
|
||||
min: Math.min(...curve[f].x),
|
||||
max: Math.max(...curve[f].x),
|
||||
};
|
||||
|
||||
const fMinY = Math.min(...curve[f].y);
|
||||
const fMaxY = Math.max(...curve[f].y);
|
||||
|
||||
if (fMinY < globalMinY) globalMinY = fMinY;
|
||||
if (fMaxY > globalMaxY) globalMaxY = fMaxY;
|
||||
|
||||
// Normalize curves
|
||||
this.normalizedCurve[f] = this.normalizeCurve(curve[f], this.normMin, this.normMax);
|
||||
|
||||
}
|
||||
|
||||
this.normalizedSplines = this.buildXySplines(this.normalizedCurve, this.interpolationType);
|
||||
|
||||
// Build calculated curves (same #points across all f)
|
||||
for (const f of Object.keys(this.normalizedCurve)) {
|
||||
this.calculatedCurve[f] = this.buildCalculatedCurve(this.normalizedSplines, f, this.calculationPoints);
|
||||
}
|
||||
|
||||
this.fCurve = this.buildFCurve(this.calculatedCurve, this.calculationPoints);
|
||||
this.fSplines = this.buildFSplines(this.fCurve, this.interpolationType);
|
||||
|
||||
const fKeys = Object.keys(curve).map(Number);
|
||||
this.fValues.min = Math.min(...fKeys);
|
||||
this.fValues.max = Math.max(...fKeys);
|
||||
|
||||
this.yValues.lowest = globalMinY;
|
||||
this.yValues.highest = globalMaxY;
|
||||
|
||||
// Set initial fDimension to min
|
||||
this.fDimension = this.fValues.min;
|
||||
this.logger.debug(` !!! Initial fDimension set to ${this.fValues.min}`);
|
||||
}
|
||||
|
||||
normalizeVal(val, normMin, normMax) {
|
||||
return this.interpolation.interpolate_lin_single_point(val, normMin, normMax, 1, this.calculationPoints);
|
||||
}
|
||||
|
||||
normalizeCurve(curve, normMin, normMax) {
|
||||
return {
|
||||
x: this.interpolation.interpolate_lin_curve_points(curve.x, normMin, normMax),
|
||||
y: curve.y,
|
||||
};
|
||||
}
|
||||
|
||||
denormalizeXvals(xValues) {
|
||||
// Retrieve the normalized x-array from the current Fxy curve
|
||||
const normalizedX = xValues;
|
||||
|
||||
// Map each normalized x to its denormalized value
|
||||
const denormalizedX = normalizedX.map(nx => {
|
||||
return this.interpolation.interpolate_lin_single_point(
|
||||
nx,
|
||||
this.normMin,
|
||||
this.normMax,
|
||||
this.currentFxyXMin,
|
||||
this.currentFxyXMax
|
||||
);
|
||||
});
|
||||
|
||||
// Return a new object with denormalized x and the original y array
|
||||
return denormalizedX;
|
||||
}
|
||||
|
||||
// interpolate input x value to denormalized x value
|
||||
denormalizeX(x) {
|
||||
return this.interpolation.interpolate_lin_single_point(
|
||||
x,
|
||||
this.normMin,
|
||||
this.normMax,
|
||||
this.currentFxyXMin,
|
||||
this.currentFxyXMax
|
||||
);
|
||||
}
|
||||
|
||||
buildCalculatedCurve(splines, f, pointsCount) {
|
||||
const cCurve = { x: [], y: [] };
|
||||
for (let i = 1; i <= pointsCount; i++) {
|
||||
const nx = this.interpolation.interpolate_lin_single_point(i, 1, pointsCount, this.normMin, this.normMax);
|
||||
cCurve.x.push(nx);
|
||||
cCurve.y.push(splines[f].interpolate(nx));
|
||||
}
|
||||
return cCurve;
|
||||
}
|
||||
|
||||
buildFCurve(curve, pointsCount) {
|
||||
const fCurve = {};
|
||||
for (let i = 0; i < pointsCount; i++) {
|
||||
fCurve[i] = { x: [], y: [] };
|
||||
}
|
||||
|
||||
for (let i = 0; i < pointsCount; i++) {
|
||||
for (const [f, val] of Object.entries(curve)) {
|
||||
fCurve[i].x.push(Number(f));
|
||||
fCurve[i].y.push(val.y[i]);
|
||||
}
|
||||
}
|
||||
return fCurve;
|
||||
}
|
||||
|
||||
buildFSplines(fCurve, type) {
|
||||
const fSplines = {};
|
||||
for (const i of Object.keys(fCurve)) {
|
||||
fSplines[i] = this.loadSpline(fCurve[i], type);
|
||||
}
|
||||
return fSplines;
|
||||
}
|
||||
|
||||
buildSingleFxyCurve(fSplines, cCurve, f, pointsCount) {
|
||||
const singleCurve = { [f]: { x: [], y: [] } };
|
||||
const keys = Object.keys(cCurve);
|
||||
const firstKey = keys[0];
|
||||
|
||||
for (let i = 0; i < pointsCount; i++) {
|
||||
singleCurve[f].x.push(cCurve[firstKey].x[i]);
|
||||
singleCurve[f].y.push(fSplines[i].interpolate(f));
|
||||
}
|
||||
|
||||
return singleCurve;
|
||||
}
|
||||
|
||||
buildXySplines(curves, type) {
|
||||
const xySplines = {};
|
||||
for (const f of Object.keys(curves)) {
|
||||
xySplines[f] = this.loadSpline(curves[f], type);
|
||||
}
|
||||
return xySplines;
|
||||
}
|
||||
|
||||
loadSpline(curve, type) {
|
||||
const splineObj = new Interpolation();
|
||||
splineObj.load_spline(curve.x, curve.y, type);
|
||||
return splineObj;
|
||||
}
|
||||
|
||||
calculateFxyXRange(value) {
|
||||
|
||||
const keys = Object.keys(this.inputCurve).map(Number).sort((a, b) => a - b);
|
||||
for (let i = 0; i < keys.length; i++) {
|
||||
const cur = keys[i];
|
||||
const next = keys[i + 1];
|
||||
|
||||
if (value === cur) {
|
||||
this.currentFxyXMin = this.xValues[cur].min;
|
||||
this.currentFxyXMax = this.xValues[cur].max;
|
||||
return;
|
||||
}
|
||||
|
||||
if (next && value > cur && value < next) {
|
||||
this.currentFxyXMin = this.interpolation.interpolate_lin_single_point(
|
||||
value, cur, next, this.xValues[cur].min, this.xValues[next].min
|
||||
);
|
||||
this.currentFxyXMax = this.interpolation.interpolate_lin_single_point(
|
||||
value, cur, next, this.xValues[cur].max, this.xValues[next].max
|
||||
);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
getOutput() {
|
||||
return {
|
||||
x: this.currentX,
|
||||
y: this.yOutput,
|
||||
f: this.currentF,
|
||||
yOutputPosVsPeak: {
|
||||
peakOnlyPercentage: this.calcRelativePositionToPeak(this.currentFxyCurve[this.fDimension], this.outputY).peakOnlyPercentage,
|
||||
rangeBasedPercentage: this.calcRelativePositionToPeak(this.currentFxyCurve[this.fDimension], this.outputY).rangeBasedPercentage
|
||||
},
|
||||
posXyPeak: this.getPosXofYpeak(this.currentFxyCurve[this.fDimension]),
|
||||
xRange: { min: this.currentFxyXMin, max: this.currentFxyXMax },
|
||||
yRange: { min: this.currentFxyYMin, max: this.currentFxyYMax },
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = Predict;
|
||||
|
||||
/*
|
||||
// Example usage
|
||||
let example =
|
||||
{
|
||||
0:
|
||||
{
|
||||
x:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
|
||||
y:[5, 15, 25, 35, 45, 55, 45, 35, 25, 15],
|
||||
},
|
||||
100:
|
||||
{
|
||||
x:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
|
||||
y:[50, 150, 250, 350, 450, 550, 450, 350, 250, 150],
|
||||
}
|
||||
}
|
||||
|
||||
//set curve data in config
|
||||
let config = {curve:example};
|
||||
|
||||
var predict = new Predict(config=config);
|
||||
|
||||
console.log(" showing curve data");
|
||||
console.log(predict.inputCurveData);
|
||||
|
||||
console.log(" showing config data");
|
||||
console.log(predict.config);
|
||||
|
||||
// specify dimension f if there is no dim f then specify 0 as example 2
|
||||
console.log(" showing config data");
|
||||
console.log(predict.config);
|
||||
|
||||
console.log(`lowest y value ever seen : ${predict.yValues.lowest}`);
|
||||
console.log(`higehst y value ever seen : ${predict.yValues.highest}`);
|
||||
|
||||
predict.fDimension = 0;
|
||||
|
||||
console.log(`default x : ${predict.currentX}`);
|
||||
console.log(`min x : ${predict.currentFxyXMin} , max x : ${predict.currentFxyXMax} for f : ${predict.fDimension}`);
|
||||
console.log(`min y : ${predict.currentFxyYMin} , max y : ${predict.currentFxyYMax} for f : ${predict.fDimension}`);
|
||||
console.log(`Y prediction is= ${predict.outputY} @ f : ${predict.fDimension} `);
|
||||
|
||||
// specify x value to predict y
|
||||
const yVal = predict.y(x=0);
|
||||
console.log(`For x : ${predict.currentX} is the predicted value ${yVal} @ f : ${predict.fDimension} `);
|
||||
console.log(predict.retrieveActiveCurve());
|
||||
const peak = predict.getLocalPeak(predict.currentFxyCurve[predict.fDimension].y);
|
||||
|
||||
console.log(predict.getPosXofYpeak(predict.currentFxyCurve[predict.fDimension]));
|
||||
|
||||
const { peakOnlyPercentage, rangeBasedPercentage } = predict.calcRelativePositionToPeak(predict.currentFxyCurve[predict.fDimension], predict.outputY);
|
||||
console.log(`Peak-only percentage: ${peakOnlyPercentage}%, Range-based percentage: ${rangeBasedPercentage}%`);
|
||||
|
||||
|
||||
//*/
|
||||
Reference in New Issue
Block a user