node-red-contrib-prib-functions 0.19.2 → 0.21.0

package/dataAnalysis/dataAnalysis.html

@@ -7,10 +7,11 @@
             name: {value:"",required:false},
 		    action: {value:"avg",required:true},
 		    columns:{value:"",required:false},
+		    lag: {value:1,required:true},
 		    outputs: {value:(["realtime","realtimePredict"].includes(this.action)?3:2),required:true},
 		    outliersBase: {value:"avg",required:false},
 		    outliersStdDevs: {value:"3",required:false},
-		    term: {value:"10",required:false},
+		    term: {value:10,required:false},
 		    keyProperty: {value:"msg.topic",required:false},
 		    dataProperty: {value:"msg.payload",required:false},
 		    dataProperties: {value:["msg.payload[0]","msg.payload[1]"],required:false}
@@ -27,6 +28,7 @@
         },
         oneditprepare: function() {
         	const node=this;
+			node.lag??=1
         	$("#node-input-keyProperty").change(function() {
             	if( [null,""].includes(node.keyProperty) ) {
    	   			 	$(this).val("msg.topic");
@@ -45,49 +47,62 @@
         		}
            	});
 	       	$("#node-input-action").change(function() {
-        		 if(["distances","distancesMax","distancesMin"].includes( $(this).val() )) {
+				if(["differenceSeasonal","differenceSeasonalSecondOrder","realtime","realtimePredict"].includes( $(this).val() )) {
+        			$(".form-row-http-in-lag").show(); 
+        		} else {
+        			$(".form-row-http-in-lag").hide();
+        		}
+        		if(["distances","distancesMax","distancesMin"].includes( $(this).val() )) {
         			$(".form-row-http-in-columns").show(); 
-        		 } else {
+        		} else {
         			$(".form-row-http-in-columns").hide();
-        		 }
+        		}
         		 if(["movingAvgSimple","movingAvgWeighted","movingAvgExponential","realtime","realtimePredict"].includes( $(this).val() )) {
         			$(".form-row-http-in-term").show(); 
-        		 } else {
+        		} else {
         			$(".form-row-http-in-term").hide();
-        		 }
-        		 if(["movingAvgExponential"].includes( $(this).val() )) {
+        		}
+        		if(["movingAvgExponential"].includes( $(this).val() )) {
         			$("#node-input-term").attr({min:0,max:1,step:0.1});
 					if(node.term<0 || node.term>1) $("#node-input-term").val(0.5);
 	       			$("#node-input-term").change(function() {
 						if(node.term<0) $(this).val(0);
 						if(node.term>1) $(this).val(1);
 					});
-        		 } else {
+        		} else {
+        			$("#node-input-lag").attr({min:1,max:1000,step:1});
+					$("#node-input-lag").change(function() {
+						const v=$(this).val();
+						if(v<1) $(this).val(1);
+						if(v>1000) $(this).val(1000);
+					});
         			$("#node-input-term").attr({min:1,max:100,step:1});
 	       			$("#node-input-term").change(function() {
-						if(node.term<1) $(this).val(1);
-						if(node.term>100) $(this).val(100);
+						const v=$(this).val()
+						if(v<1) $(this).val(1);
+						if(v>100) $(this).val(100);
 					});
-        		 }        		 
-        		 if(["realtime","realtimePredict"].includes( $(this).val() )) {
+        		}        		 
+        		if(["realtime","realtimePredict"].includes( $(this).val() )) {
 	        		node.outputs=3;
            			$(".form-row-http-in-keyProperty").show();
            			$(".form-row-http-in-outliersStdDevs").show();
            			$(".form-row-http-in-outliersBase").show();
 					$("#node-input-outliersStdDevs").change();
-           		 } else {
+           		} else {
            			node.outputs=2;
            			$(".form-row-http-in-keyProperty").hide();
            			$(".form-row-http-in-outliersStdDevs").hide();
            			$(".form-row-http-in-outliersBase").hide();
-        		 }        		 
-        		 if(["pearsonR","covariance","corelationship"].includes( $(this).val() )) {
+        		}        		 
+        		if(["pearsonR","covariance","corelationship"].includes( $(this).val() )) {
            			$(".node-input-dataProperties-container-row").show();
            			$(".form-row-http-in-dataProperty").hide();
-           		 } else {
+           		} else {
            			$(".node-input-dataProperties-container-row").hide();
            			$(".form-row-http-in-dataProperty").show();
-        		 }        		 
+        		}        		 
+				$("#node-input-lag").change();
 				$("#node-input-term").change();
         	});
 	       	
@@ -148,6 +163,10 @@
             <option value="corelationship">Corelationship</option>
             <option value="deltas">Deltas</option>
             <option value="deltaNormalised">Deltas Normalised</option>
+			<option value="difference">Difference</option>
+			<option value="differenceSeasonal">Difference Seasonal</option>
+			<option value="differenceSeasonalSecondOrder">Difference Seasonal Second Order</option>
+			<option value="differenceSecondOrder">Difference Second Order</option>
             <option value="distances">Euclidean Distances</option>
             <option value="distancesMax">Euclidean Distances Max</option>
             <option value="distancesMin">Euclidean Distances Min</option>
@@ -162,6 +181,7 @@
             <option value="movingAvgExponential">Moving Average Exponential (EMA/EWMA)</option>
             <option value="normalize">Normalise</option>
             <option value="pearsonR">Pearson Product Moment Correlation (PPMC)</option>
+			<option value="randomise">Randomise</option>
             <option value="range">Range</option>
             <option value="realtime">RealTime Metrics</option>
             <option value="realtimePredict">RealTime Metrics + predicts</option>
@@ -179,6 +199,11 @@
         <label for="node-input-columns"><i class="icon-bookmark"></i> Columns</label>
         <input type="text" id="node-input-columns" placeholder="columns">
     </div>
+    
+	<div class="form-row form-row-http-in-lag hide">
+        <label for="node-input-lag"><i class="icon-bookmark"></i> Lag</label>
+        <input type="number" id="node-input-lag" placeholder="lag" min="1" max="10000" step="1">
+    </div>
 
     <div class="form-row form-row-http-in-term hide">
         <label for="node-input-term"><i class="icon-bookmark"></i> Term</label>
@@ -231,12 +256,18 @@ Data is not persisted so metrics start from zero sample set on node recycle.
 	<p>
 If real-time stats then a message can send directive instruction in topic: 
 <dl>
-<dt>"@predict <key>"<\dt><dd></dd>Send send predictions to second port for selected key.
-<dt>"@stats"<\dt><dd></dd>send all stored metrics and retained datapoints to second port.
-<dt>"@stats reset"<\dt><dd>Reset all stats and "@stats reset <key>" will reset a particular data point.</dd>
-<dt>"@stats set"<\dt><dd>Set stats with ith msg.payload and "@stats set <a data point>" will set a particular data point with msg.payload.</dd>
+  <dt>"@predict <key>"</dt><dd></dd>Send send predictions to second port for selected key.
+  <dt>"@stats"</dt><dd></dd>send all stored metrics and retained datapoints to second port.
+  <dt>"@stats reset"</dt><dd>Reset all stats and "@stats reset <key>" will reset a particular data point.</dd>
+  <dt>"@stats set"</dt><dd>Set stats with ith msg.payload and "@stats set &lt;a data point&gt;" will set a particular data point with msg.payload.</dd>
 </dl>
 	</p>
+<dl>
+	<dt>Lag</dt><dd>If greater that 1 generates seasonal difference with degree lag</dd>
+	<dt>Term</dt><dd>The depth of moving Average</dd>
+</dl>
+	<p>
+ 	</p>
 	<p>
 	Outliers are not within:
 		<ul>	

package/dataAnalysis/dataAnalysis.js

@@ -2,6 +2,11 @@ const logger = new (require("node-red-contrib-logger"))("Data Analysis");
 logger.sendInfo("Copyright 2020 Jaroslav Peter Prib");
 
 require("./arrayLast");
+require("./arrayDifference")
+require("./arrayDifferenceSeasonal")
+require("./arrayDifferenceSeasonalSecondOrder")
+require("./arrayDifferenceSecondOrder")
+require("./arrayRandom")
 const ed=require("./euclideanDistance.js");
 require("./forNestedEach");
 
@@ -64,10 +69,10 @@ EMA.prototype.sample=function(value) {
 	return this;
 }
 
-function setDataPoint(value,term,node,dp) {
-	if(logger.active) logger.send({label:"setDataPoint",value:value,term,dp});
-	if(!dp.values) {
-		Object.assign(dp,{
+function setDataPoint(value,term,node,dataPoint) { 
+	if(logger.active) logger.send({label:"setDataPoint",value:value,term,dataPoint});
+	if(!dataPoint.values) {
+		Object.assign(dataPoint,{
 			values:[],
 			avg:0,
 			count:0,
@@ -78,43 +83,44 @@ function setDataPoint(value,term,node,dp) {
 			sum:0,
 			sumSquared:0,
 			sumCubed:0,
-			term:term,
+			term:term??node.term,
 			weightedMovingSum:0,
 			exponentialWeightedMoving:[new EMA(0.25),new EMA(0.5),new EMA(0.75)]
 		});
-	}
-	;
-	const count=++dp.count,values=dp.values;
+	};
+	const count=++dataPoint.count,values=dataPoint.values;
 	values.push(value);
-	dp.isMaxSize=(values.length>dp.term);
-	dp.removedValue=(dp.isMaxSize?values.shift():0);
-	const removedValue=dp.removedValue;
-	dp.max=Math.max(dp.max||value,value);
-	dp.min=Math.min(dp.min||value,value);
-	dp.range=dp.max-dp.min;
-	dp.sum+=value;
-	dp.sumSquared+=Math.pow(value,2);
-	dp.sumCubed+=Math.pow(value,3);
-	dp.movingSum+=value-removedValue;
-	dp.movingSumSquared+=Math.pow(value,2)-Math.pow(removedValue,2);
-	dp.movingSumCubed+=Math.pow(value,3)-Math.pow(removedValue,3);
-	dp.avg=dp.sum/count;
-	const avg=dp.avg;
-	dp.normalised=dp.range ? (value-avg)/dp.range : 0;
-	dp.movingAvg=dp.movingSum/values.length;
-	dp.variance=dp.sumSquared/count - Math.pow(avg,2);
-	dp.stdDev=Math.sqrt(dp.variance);
-	dp.movingVariance=dp.movingSumSquared/values.length - Math.pow(dp.movingAvg,2);
-	dp.movingStdDev=Math.sqrt(dp.movingVariance);
-	dp.median=functions.median(values);
-	dp.standardized=( (value-avg)/dp.stdDev )||0;
-	dp.movingStandardized=( (value-dp.movingAvg)/dp.movingStdDev )||0;
-	dp.skewness=(dp.sumCubed-3*avg*dp.variance-Math.pow(avg,3))/dp.variance*dp.stdDev;
-	dp.movingSkewness=(dp.movingSumCubed-3*dp.movingAvg*dp.movingVariance-Math.pow(dp.movingAvg,3))/dp.movingVariance*dp.stdDev;
-	dp.outlier=node.outliersFunction(node,dp,value);
-	dp.weightedMovingSum+=count*value;
-	dp.weightedMovingAvg=(dp.weightedMovingAvg*2/count)/(count+1);
-	dp.exponentialWeightedMoving.forEach(c=>c.sample(value));
+	const movingTerm=Math.min(values.length,dataPoint.term)
+	dataPoint.isMaxSize=(values.length>dataPoint.maxSize);
+	dataPoint.removedMovingValue=(dataPoint.isMaxSize?values[values.length-dataPoint.term]:0);
+	dataPoint.removedValue=(dataPoint.isMaxSize?values.shift():0);
+	const removedMovingValue=dataPoint.removedMovingValue;
+	dataPoint.max=Math.max(dataPoint.max||value,value);
+	dataPoint.min=Math.min(dataPoint.min||value,value);
+	dataPoint.range=dataPoint.max-dataPoint.min;
+	dataPoint.sum+=value;
+	dataPoint.sumSquared+=Math.pow(value,2);
+	dataPoint.sumCubed+=Math.pow(value,3);
+	dataPoint.movingSum+=value-removedMovingValue;
+	dataPoint.movingSumSquared+=Math.pow(value,2)-Math.pow(removedMovingValue,2);
+	dataPoint.movingSumCubed+=Math.pow(value,3)-Math.pow(removedMovingValue,3);
+	dataPoint.avg=dataPoint.sum/count;
+	const avg=dataPoint.avg;
+	dataPoint.normalised=dataPoint.range ? (value-avg)/dataPoint.range : 0;
+	dataPoint.movingAvg=dataPoint.movingSum/movingTerm;
+	dataPoint.variance=dataPoint.sumSquared/count - Math.pow(avg,2);
+	dataPoint.stdDev=Math.sqrt(dataPoint.variance);
+	dataPoint.movingVariance=dataPoint.movingSumSquared/movingTerm - Math.pow(dataPoint.movingAvg,2);
+	dataPoint.movingStdDev=Math.sqrt(dataPoint.movingVariance);
+	dataPoint.median=functions.median(values);
+	dataPoint.standardized=( (value-avg)/dataPoint.stdDev )||0;
+	dataPoint.movingStandardized=( (value-dataPoint.movingAvg)/dataPoint.movingStdDev )||0;
+	dataPoint.skewness=(dataPoint.sumCubed-3*avg*dataPoint.variance-Math.pow(avg,3))/dataPoint.variance*dataPoint.stdDev;
+	dataPoint.movingSkewness=(dataPoint.movingSumCubed-3*dataPoint.movingAvg*dataPoint.movingVariance-Math.pow(dataPoint.movingAvg,3))/dataPoint.movingVariance*dataPoint.stdDev;
+	dataPoint.outlier=node.outliersFunction(node,dataPoint,value);
+	dataPoint.weightedMovingSum+=count*value;
+	dataPoint.weightedMovingAvg=(dataPoint.weightedMovingAvg*2/count)/(count+1);
+	dataPoint.exponentialWeightedMoving.forEach(c=>c.sample(value));
 }
 function getColumns(node) {
 	if(node.columns) {
@@ -157,6 +163,10 @@ functions={
 	},
 	distancesMin: (d,term,node)=>ed.minDistances(d,getColumns(node)),
 	distancesMax: (d,term,node)=>ed.maxDistances(d,getColumns(node)),
+	difference: (d)=>d.difference(),
+	differenceSeasonal: (d,term,node)=>d.differenceSeasonal(node.lag),
+	differenceSeasonalSecondOrder: (d,term,node)=>d.differenceSeasonalSecondOrder(node.lag),
+	differenceSecondOrder: (d)=>d.differenceSecondOrder(),
 	max: (d)=> Math.max(...d),
 	median:(d)=>{
 		const i=Math.floor(d.length/2);
@@ -214,9 +224,9 @@ functions={
 			}
 		}
 		node.samples++;
-		for(let v,dp,i=0; i<node.dataProperties.length; i++) {
-			v=d[i];
-			dp=node.dataPoints[i];
+		for(let i=0; i<node.dataProperties.length; i++) {
+			const v=d[i];
+			const dp=node.dataPoints[i];
 			dp.sum+=v;
 			dp.sumSquared+=v*v;
 			for(let j=i+1; j<node.dataProperties.length; j++) {
@@ -271,10 +281,23 @@ functions={
 		}
 		setDataPoint(d.value,term,node,dp);
 		if(dp.delta) {
-			setDataPoint(d.value-dp.values[dp.values.length-2],term,node,dp.delta);
+			if(dp.values.length>1)
+				setDataPoint(d.value-dp.values[dp.values.length-2],term,node,dp.delta);
 		} else {
 			dp.delta={};
 		}
+		if(node.lag>1) {
+			const vectorSize=dp.values.length
+			if(dp.lag) {
+				if(node.lag<=vectorSize){
+				  setDataPoint(d.value-dp.values[vectorSize-node.lag],term,node,dp.lag)
+				  const values=dp.lag.values
+				  if(values.length>1) setDataPoint(values[values.length-1]-values[values.length-2],term,node,dp.lag.delta)
+				}
+			} else {
+				dp.lag={delta:{}}
+			}
+		}
 		return dp;
 	},
 	sampleVariance:(d)=>{
@@ -301,11 +324,15 @@ module.exports = function (RED) {
 	function dataAnalysisNode(n) {
 		RED.nodes.createNode(this, n);
 		const node=Object.assign(this,
-			{outliersStdDevs:3,crossNormalisedDeltas:crossNormalisedDeltas.bind(this)},
+			{outliersStdDevs:3,crossNormalisedDeltas:crossNormalisedDeltas.bind(this),lag:1,term:3},
 			n,
 			{maxErrorDisplay:10,dataPoint:{}}
 		);
 		try{
+			node.lag=Number(node.lag)
+			if(Number(node.term)==NaN)throw Error("term not a number, value:"+JSON.stringify(node.term))
+			node.term=Number(node.term)
+			node.maxSize=Math.max(node.term,node.lag)
 			if(functions.hasOwnProperty(node.action)) {
 				node.actionfunction=functions[node.action];
 			} else {
@@ -313,7 +340,7 @@ module.exports = function (RED) {
 			}
 			switch (node.action) {
 			case "realtime":
-					node.outliersStdDevs=Number.parseInt(node.outliersStdDevs,10)||3;
+				node.outliersStdDevs=Number.parseInt(node.outliersStdDevs,10)||3;
 				if(![1,2,3].includes(node.outliersStdDevs)) throw Error("outlier std deviation "+node.outliersStdDevs+" not 1,2 or 3");
 				const outliersFunction=(node.outliersBase||"avg")=="median";
 				node.log("realtime outliersBase set avg "+outliersFunction);
@@ -340,6 +367,7 @@ module.exports = function (RED) {
 			node.getData=eval(node.getDatafunction);
 			node.status({fill:"green",shape:"ring",text:"Ready"});
 		} catch(ex) {
+			if(logger.active) logger.send({label:"initialise error",action:node.action,message:ex.message,stack:ex.stack});
 			logger.send({label:"initialise error",node:n});
 			node.error(ex);
 			node.status({fill:"red",shape:"ring",text:"Invalid setup "+ex.message});
@@ -379,6 +407,7 @@ module.exports = function (RED) {
 						throw Error("unknown");
 					}
 				} catch(ex) {
+					if(logger.active) logger.send({label:"error input",action:node.action,message:ex.message,stack:ex.stack});
 					node.error(msg.topic+" failed "+ex.message);
 				}
 	 			return;
@@ -395,10 +424,10 @@ module.exports = function (RED) {
 					break;
 				}
 			} catch(ex) {
-				if(logger.active) logger.send({label:"error input",action:node.action,message:ex.message,stack:ex.stack});
 				msg.error=ex.message;
 				if(node.maxErrorDisplay) {
 					--node.maxErrorDisplay;
+					logger.send({label:"error input",action:node.action,message:ex.message,stack:ex.stack});
 					if(node.action=="realtime") {
 						node.error(node.action+" error: "+ex.message);
 					} else {

package/dataAnalysis/generateMatrixFunction.js

@@ -0,0 +1,89 @@
+function generatedMatrixFunction(arg1) {
+    if(typeof arg1 !=="object") throw Error("no definitional JSON found");
+    Object.assign(this,{
+        args:[],
+        dimensionOrder:["row","column"],
+        returnValue:"this",
+        debug:false
+    },arg1);
+    const extendedArgs=[
+        this.dimensionOrder[0]+"StartOffset=0",
+        this.dimensionOrder[0]+"EndOffset",
+        this.dimensionOrder[1]+"StartOffset=0",
+        this.dimensionOrder[1]+"EndOffset",
+        "returnValue="+this.returnValue,
+        "matrixEndOffset=matrix.length-1",
+        "rowOffset",
+        "columnOffset",
+        "rowVectorOffset",
+        "columnVectorOffset",
+        "elementOffset",
+        "element",
+        "getElementArray=()=>matrix[rowOffset][columnOffset]",
+        "getElementVector=()=>matrix[elementOffset]",
+        "setElementArray=(v)=>matrix[rowOffset][columnOffset]=v",
+        "setElementVector=(v)=>matrix[elementOffset]=v",
+        "getElement=getElementVector",
+        "setElement=setElementVector",
+        "getMatrix=()=>Object.create(Object.getPrototypeOf(matrix))",
+        "arrayFunctions={"+
+          "forEachRowColumn:(call)=>{for(rowOffset=0;rowOffset<=rowEndOffset;rowOffset++) call()},"+
+          "forEachColumnRow:(call)=>{for(columnOffset=0;columnOffset<=columnEndOffset;columnOffset++) call()}"+
+          "}",
+        "vectorFunctions={}"
+    ];
+    const functionCode=
+        "("+["matrix","rows",
+            "columns"
+            ].concat(this.args,extendedArgs).join()+
+        ")=>{\n"+
+        "  const isArray=(matrix!==null&&matrix instanceof Array)\n"+
+        "  if(isArray){\n"+
+        "    rows=matrix.length\n"+
+        "    columns=matrix[0].length\n"+
+        "    getElement=getElementArray\n"+
+        "    setElement=setElementArray\n"+
+        "  }\n"+
+        "  if(rows<=0) throw Error('rows < 1')\n"+
+        "  if(columns<=0) throw Error('rows < 1')\n"+
+        "  if(rowEndOffset==null) rowEndOffset=rows-1\n"+
+        "  if(columnEndOffset==null) columnEndOffset=columns-1\n"+
+        (this.debug?"console.log({matrix:matrix,matrixEndOffset:matrixEndOffset,rowEndOffset:rowEndOffset,columnEndOffset:columnEndOffset,rows:rows,columns:columns})\n":"")+
+        "  if(isArray){\n"+
+        "    for("+this.dimensionOrder[0]+"Offset="+this.dimensionOrder[0]+"StartOffset;"+this.dimensionOrder[0]+"Offset<="+this.dimensionOrder[0]+"EndOffset;"+this.dimensionOrder[0]+"Offset++){\n"+
+        "      const "+this.dimensionOrder[0]+"=matrix["+this.dimensionOrder[0]+"Offset]\n"+
+        (this.debug?"console.log({"+this.dimensionOrder[0]+"Offset:"+this.dimensionOrder[0]+"Offset,})\n":"")+"\n"+
+        "      for("+this.dimensionOrder[1]+"Offset="+this.dimensionOrder[1]+"StartOffset;"+this.dimensionOrder[1]+"Offset<="+this.dimensionOrder[1]+"EndOffset;"+this.dimensionOrder[1]+"Offset++){\n"+
+        "        const element=matrix["+this.dimensionOrder[1]+"Offset]\n"+
+        (this.debug?"console.log({"+this.dimensionOrder[1]+"Offset:"+this.dimensionOrder[1]+"Offset,element:element})\n":"")+
+                 this.code+"\n"+
+        "      }\n"+
+        "    }\n"+
+        "  } else {\n"+
+        "    const innerSize="+(this.dimensionOrder[0]=="row"?"columns":"1")+"\n"+
+        "    const outerSize="+(this.dimensionOrder[0]=="row"?"1":"columns")+"\n"+
+        "    for("+this.dimensionOrder[0]+"Offset="+this.dimensionOrder[0]+"StartOffset;"+this.dimensionOrder[0]+"Offset<="+this.dimensionOrder[0]+"EndOffset;"+this.dimensionOrder[0]+"Offset++){\n"+
+        "      const "+this.dimensionOrder[0]+"VectorOffset="+this.dimensionOrder[0]+"Offset*innerSize\n"+
+        (debug?"console.log({"+this.dimensionOrder[0]+"Offset:"+this.dimensionOrder[0]+"Offset,})\n":"")+
+        "      for("+this.dimensionOrder[1]+"Offset="+this.dimensionOrder[1]+"StartOffset;"+this.dimensionOrder[1]+"Offset<="+this.dimensionOrder[1]+"EndOffset;"+this.dimensionOrder[1]+"Offset++){\n"+
+        "        "+this.dimensionOrder[1]+"VectorOffset="+this.dimensionOrder[1]+"Offset*outerSize\n"+
+        "        elementOffset=rowVectorOffset +columnOffset\n"+
+        "        element=matrix[elementOffset];\n"+
+        (debug?"console.log({"+this.dimensionOrder[1]+"Offset:"+this.dimensionOrder[1]+"Offset,rowVectorOffset:rowVectorOffset,columnVectorOffset:columnVectorOffset,elementOffset:elementOffset,element:element})\n":"")+
+        "          "+this.code+"\n"+
+        "      }\n"+
+        "    }\n"+
+        "  }\n"+
+          (this.returnValue==undefined?"  return this":"  return returnValue")+
+        "\n}";
+    try{
+        const evaluatedCode=eval(functionCode);
+        return evaluatedCode;
+    } catch(ex) {
+        console.error("built function: \n"+functionCode)
+        console.error("error: "+ex.message)
+        console.error(ex.stack)
+        throw Error("code failed")
+    }
+}
+module.exports = generatedMatrixFunction;

package/dataAnalysis/generateVectorFunction.js

@@ -0,0 +1,25 @@
+function generatedVectorFunction(arg1) {
+    if(typeof arg1 !=="object") throw Error("no definitional JSON found");
+    Object.assign(this,{
+        args:[],
+        debug:false,
+        returnValue:"this"
+    },arg1);
+    const extendedArgs=["startOffset=0","endOffset=vector.length-1,returnValue="+this.returnValue]
+    const functionCode=
+        "("+["vector"].concat(this.args,extendedArgs).join()+")=>{"+
+        "for(let index=startOffset;index<=endOffset;index++){\n"+
+        this.code+";\n"+
+        "}\n"+
+        "return returnValue\n}";
+    try{
+        if(debug==true) console.log(functionCode);
+        const evaluatedCode=eval(functionCode);
+        return evaluatedCode;
+    } catch(ex) {
+        console.error("built function: "+functionCode)
+        console.error("error: "+ex.message)
+        throw Error("code failed")
+    }
+}
+module.exports = generatedVectorFunction;