node-red-contrib-prib-functions 0.18.0 → 0.20.4

package/test/dataAnalysisExtensions.js

@@ -0,0 +1,472 @@
+const assert=require('assert');
+const should=require("should");
+const m2x2=[[11,12],[21,22]]
+const m2x3=[[11,12,13],[21,22,23]]
+
+describe('generatedVectorFunction', function(){
+	const generateVectorFunction=require("../dataAnalysis/generateVectorFunction.js");
+	it("error gen", function(done){
+		assert.throws(()=>generateVectorFunction({
+			code:"=a deliberate error in test",
+			args:["arg1,arg2"]
+		}),Error("code failed"))
+		done();
+	});
+	it("for each", function(done){
+		const forEach=generateVectorFunction({
+			code:"vector[index]+=(index+1)*10",
+			args:["arg1,arg2"]
+		})
+		const vector=[1,2,3,4]
+		forEach(vector)
+		assert.deepEqual(vector,[11,22,33,44])
+		done();
+	});
+	it("for each range", function(done){
+		const forEach=generateVectorFunction({code:"vector[index]+=(index+1)*10"})
+		const vector=[1,2,3,4]
+		forEach(vector,1,2)
+		assert.deepEqual(vector,[1,22,33,4])
+		done();
+	});
+	it("sumVector", function(done){
+		const sumVector=generateVectorFunction({code:"returnValue+=vector[index]",args:[],returnValue:0})
+		const vector=[1,2,3,4]
+		assert.deepEqual(sumVector(vector),1+2+3+4)
+		done();
+	});
+	it("sumVector range", function(done){
+		const sumVector=generateVectorFunction({code:"returnValue+=vector[index]",returnValue:10})
+		const vector=[1,2,3,4]
+		assert.deepEqual(sumVector(vector,1,2,20),20+2+3)
+		done();
+	});
+	it("mapVector range", function(done){
+		const mapVector=generateVectorFunction({
+			code:"returnValue[index-startOffset]=vector[index]",
+			args:["dataType=Array"],
+			returnValue:"new dataType(1+endOffset-startOffset)"
+		})
+		const vector=[1,2,3,4]
+		assert.deepEqual(mapVector(vector,Array,1,2),[2,3])
+		done();
+	});
+	it("mapVector range Float32Array", function(done){
+		const mapVector=generateVectorFunction({
+			code:"returnValue[index-startOffset]=vector[index]",
+			args:["dataType=Array"],returnValue:"new dataType(1+endOffset-startOffset)"
+		})
+		const vector=[1,2,3,4]
+		assert.deepEqual(mapVector(vector,Float32Array,1,2),new Float32Array([2,3]))
+		done();
+	});
+});	
+describe('generateMatrixFunction', function(){
+	const generateMatrixFunction=require("../dataAnalysis/generateMatrixFunction.js")
+	const breakLogic="\nconsole.log({loop:loop});if(--loop<0) throw Error('break loop');\n"
+	const debugScript="console.log({rowOffset:rowOffset,rowEndOffset:rowEndOffset});"+
+			"console.log({columnOffset:columnOffset,columnEndOffset:columnEndOffset});"+
+			"console.log({elementOffset:elementOffset,matrixEndOffset:matrixEndOffset,element:element});"
+	it("error gen", function(done){
+		assert.throws(()=>generateMatrixFunction({
+				code:"=a deliberate error in test ",
+				args:["arg1,arg2"]
+			}),Error("code failed"))
+		done();
+	});
+	it("for each", function(done){
+		const forEach=generateMatrixFunction({
+			code:"row[columnOffset]=rowOffset*10+columnOffset"+breakLogic,
+			args:["loop=111"],
+			debug:true
+		})
+		const vector=[[1,2],[3,4]]
+		forEach(vector)
+		assert.deepEqual(vector,[[0,1],[10,11]])
+		done();
+	});
+	it("for each setElement", function(done){
+		const forEach=generateMatrixFunction({
+			code:"setElement(rowOffset*10+columnOffset)"
+		})
+		const vector=[[1,2],[3,4]]
+		forEach(vector)
+		assert.deepEqual(vector,[[0,1],[10,11]])
+		done();
+	});
+	it("for each vector", function(done){
+		const forEach=generateMatrixFunction({
+			code:"matrix[elementOffset]=rowOffset*10+columnOffset"+breakLogic,
+			args:["loop=111"],
+			debug:true
+		})
+		const vector=new Float32Array([1,2,3,4,5,6])
+		try{
+			forEach(vector,3,2)
+		} catch(ex){
+			console.error("error: "+ex.message)
+			console.error(ex.stack)
+			console.error(forEach.toString())
+			done("failed")
+		}
+		assert.deepEqual(vector,new Float32Array([0,1,10,11,20,21]))
+		done();
+	});
+	it("for each vector range row 1:1", function(done){
+		const forEach=generateMatrixFunction({
+			code:"matrix[elementOffset]=rowOffset*10+columnOffset"+breakLogic,
+			args:["loop=111"],
+			debug:true
+		})
+		const vector=new Float32Array([1,2,3,4,5,6])
+		forEach(vector,3,2,111,1,1)
+		assert.deepEqual(vector,new Float32Array([1,2,10,11,5,6]))
+		done();
+	});
+	it("for each vector range row 1:1 assign", function(done){
+		const forEach=generateMatrixFunction({
+			code:"matrix[elementOffset]=rowOffset*10+columnOffset"+breakLogic,
+			args:["loop=111"],
+			debug:true});
+		const vector=new Float32Array([1,2,3,4,5,6])
+		forEach(vector,3,2,111,1,1)
+		assert.deepEqual(vector,new Float32Array([1,2,10,11,5,6]))
+		done();
+	});
+	it("for each vector", function(done){
+		const forEach=generateMatrixFunction({
+			code:"console.log(matrix);setElement(rowOffset*10+columnOffset);console.log(matrix)"
+		})
+		const vector=new Float32Array([1,2,3,4,5,6])
+		forEach(vector,3,2)
+		assert.deepEqual(vector,new Float32Array([0,1,10,11,20,21]))
+		done();
+	});
+});	
+
+describe('sum', function(){
+	require("../dataAnalysis/arraySum.js");
+	it("array 1 to 4", function(done){
+		assert.deepEqual([1,2,3,4].sum(),1+2+3+4)
+		done();
+	});
+	it("array 2 to 4", function(done){
+		assert.deepEqual([1,2,3,4].sum(1),2+3+4)
+		done();
+	});
+	it("array 2 to 3", function(done){
+		assert.deepEqual([1,2,3,4].sum(1,2),2+3)
+		done();
+	});
+});	
+describe('sumSquared', function(){
+	require("../dataAnalysis/arraySumSquared.js");
+	it("array 1 to 4", function(done){
+		assert.deepEqual([1,2,3,4].sumSquared(),1**2+2**2+3**2+4**2)
+		done();
+	});
+	it("array 2 to 4", function(done){
+		assert.deepEqual([1,2,3,4].sumSquared(1),2**2+3**2+4**2)
+		done();
+	});
+	it("array 2 to 3", function(done){
+		assert.deepEqual([1,2,3,4].sumSquared(1,2),2**2+3**2)
+		done();
+	});
+});	
+describe('product', function(){
+	require("../dataAnalysis/arrayProduct.js");
+	it("array 1 to 4", function(done){
+		assert.deepEqual([1,2,3,4].product(),1*2*3*4)
+		done();
+	});
+	it("array 2 to 4", function(done){
+		assert.deepEqual([1,2,3,4].product(1),2*3*4)
+		done();
+	});
+	it("array 2 to 3", function(done){
+		assert.deepEqual([1,2,3,4].product(1,2),2*3)
+		done();
+	});
+});	
+describe('arrayDifference', function(){
+	require("../dataAnalysis/arrayDifference.js");
+	it("empty", function(done){
+		const result=[].difference();
+		console.log(result)
+		assert.deepEqual(result,[])
+		done();
+	});
+	it("1 value", function(done){
+		const result=[1].difference();
+		console.log(result)
+		assert.deepEqual(result,[])
+		done();
+	});
+	it("zero", function(done){
+		const result=[1,1,1,1,1].difference();
+		console.log(result)
+		assert.deepEqual(result,[0,0,0,0])
+		done();
+	});
+	it("equal 1", function(done){
+		const result=[0,1,2,3,4].difference();
+		console.log(result)
+		assert.deepEqual(result,[1,1,1,1])
+		done();
+	});
+	it("variance", function(done){
+		const result=[0,0,1,3,6].difference();
+		console.log(result)
+		assert.deepEqual(result,[0,1,2,3])
+		done();
+	});
+});
+describe('arrayDifferenceSecondOrder', function(){
+	require("../dataAnalysis/arrayDifferenceSecondOrder.js");
+	it("empty", function(done){
+		const result=[].differenceSecondOrder();
+		console.log(result)
+		assert.deepEqual(result,[])
+		done();
+	});
+	it("1 value", function(done){
+		const result=[1].differenceSecondOrder();
+		console.log(result)
+		assert.deepEqual(result,[])
+		done();
+	});
+	it("2 values", function(done){
+		const result=[1,2].differenceSecondOrder();
+		console.log(result)
+		assert.deepEqual(result,[])
+		done();
+	});
+	it("zero", function(done){
+		const result=[1,1,1].differenceSecondOrder();
+		console.log(result)
+		assert.deepEqual(result,[1-1-1+1]) //[0]
+		done();
+	});
+	it("zero x 2", function(done){
+		const result=[1,1,1,1].differenceSecondOrder();
+		console.log(result)
+		assert.deepEqual(result,[0,0])
+		done();
+	});
+	it("one", function(done){
+		const result=[0,1,2].differenceSecondOrder();
+		console.log(result)
+		assert.deepEqual(result,[(0-1)-(1-2)]) 
+		done();
+	});
+	it("one x 2", function(done){
+		const result=[0,1,2,3].differenceSecondOrder();
+		console.log(result)
+		assert.deepEqual(result,[(0-1)-(1-2),(1-2)-(2-3)])
+		done();
+	});
+	it("variance", function(done){
+		const result=[1,2,3,5,9].differenceSecondOrder();
+		console.log(result)
+		assert.deepEqual(result,[(1-2)-(2-3),(2-3)-(3-5),(3-5)-(5-9)]) 
+		done();
+	});
+	it("differenceSecondOrder=difference(1)", function(done){
+		const result1=[1,2,3,5,9].differenceSecondOrder();
+		const result2=[1,2,3,5,9].difference(1);
+		console.log(result1,result2)
+		assert.deepEqual(result1,result2) 
+		done();
+	});
+});
+describe('arrayDifferenceSeasonal', function(){
+	require("../dataAnalysis/arrayDifferenceSeasonal.js");
+	it("value=[]", function(done){
+		const result=[].differenceSeasonal();
+		assert.deepEqual(result,[])
+		const result1=[].differenceSeasonal(2);
+		assert.deepEqual(result1,[])
+		const result11=[].differenceSeasonal(1,1);
+		assert.deepEqual(result11,[])
+		done();
+	});
+	it("value=[1]", function(done){
+		const v=[1]
+		const result=v.differenceSeasonal();
+		assert.deepEqual(result,[])
+		const result1=v.differenceSeasonal(2);
+		assert.deepEqual(result1,[])
+		const result11=v.differenceSeasonal(1,1);
+		assert.deepEqual(result11,[])
+		done();
+	});
+	it("value=[1,2]", function(done){
+		const v=[1,2]
+		const result=v.differenceSeasonal();
+		assert.deepEqual(result,[1])
+		const result1=v.differenceSeasonal(2);
+		assert.deepEqual(result1,[])
+		const result11=v.differenceSeasonal(1,1);
+		assert.deepEqual(result11,[])
+		done();
+	});
+	it("value=[1,2,3,1,2,3] lag 3", function(done){
+		const v=[1,2,3,1,2,3]
+		const result=v.differenceSeasonal(3);
+		assert.deepEqual(result,[0,0,0])
+		done();
+	});
+	it("value=[1,2,3,2,3,4] lag 3", function(done){
+		const v=[1,2,3,2,3,4]
+		const result=v.differenceSeasonal(3);
+		assert.deepEqual(result,[1,1,1])
+		done();
+	});
+});
+describe('arrayForEachRange', function(){
+	require("../dataAnalysis/arrayForEachRange.js");
+	it("array 2 to 3", function(done){
+		const result=[];
+		[0,1,2,3,4].forEachRange(2,3,(v,i,a)=>result.push(v));
+		assert.deepEqual(result,[2,3])
+		done();
+	});
+	it("array 3 to 2", function(done){
+		const result=[];
+		[0,1,2,3,4].forEachRange(3,2,(v,i,a)=>result.push(v));
+		assert.deepEqual(result,[3,2])
+		done();
+	});
+	it("array ", function(done){
+		const result=[];
+		[0,1,2,3,4].forEachRange(2,3,(v,i,a)=>result.push(v));
+		assert.deepEqual(result,[2,3])
+		done();
+	});
+});	
+describe('arrayReduceRange', function(){
+	require("../dataAnalysis/arrayReduceRange.js");
+	it("array 3", function(done){
+		const result=[0,1,2,3,4].reduceRange(3,3,(a,value,i,vector)=>a+value);
+		assert.deepEqual(result,3)
+		done();
+	});
+	it("array ", function(done){
+		const result=[0,1,2,3,4].reduceRange(2,3,(a,value,i,vector)=>a+value);
+		assert.deepEqual(result,2+3)
+		done();
+	});
+});
+describe('arrayRandom', function(){
+	require("../dataAnalysis/arrayRandom.js");
+	it("array 3", function(done){
+		const result=[0,1,2,3,4].random();
+		console.log(result)
+		assert.notDeepEqual(result,[0,1,2,3,4])
+		done();
+	});
+});	
+describe('arraySwap', function(){
+	require("../dataAnalysis/arraySwap.js");
+	it("array 2 to 3", function(done){
+		const result=[];
+		[0,1,2,3,4].swap(2,3);
+		assert.deepEqual([0,1,2,3,4].swap(2,3),[0,1,3,2,4])
+		done();
+	});
+});	
+describe('arrayScale', function(){
+	require("../dataAnalysis/arrayScale.js");
+	it("array all", function(done){
+		const result=[];
+		[0,1,2,3,4].scale(2);
+		assert.deepEqual([0,1,2,3,4].scale(2),[0,1*2,2*2,3*2,4*2])
+		done();
+	});
+	it("array 1,2", function(done){
+		const result=[];
+		[0,1,2,3,4].scale(2);
+		assert.deepEqual([0,1,2,3,4].scale(2,1,2),[0,1*2,2*2,3,4])
+		done();
+	});
+});	
+describe('arrayCompareToPrecision', function(){
+	require("../dataAnalysis/arrayCompareToPrecision.js");
+	const arrayl=[0.12];
+	const array1=[0.12,1.123];
+	const array2=[0.12,1.124];
+	it("length mismatch", function(done){
+		assert.throws(()=>arrayl.compareToPrecision(array1,2))
+		done();
+	});
+	it("vector precision 2", function(done){
+		assert.doesNotThrow(()=>array1.compareToPrecision(array2,2))
+		done();
+	});
+	it("vector precision 3", function(done){
+		assert.throws(()=>array1.compareToPrecision(array2,4))
+		done();
+	});
+});	
+describe('arrayCompareToPrecision Float', function(){
+	require("../dataAnalysis/arrayCompareToPrecision.js");
+	const arrayl=new Float32Array([0.12]);
+	const array1=new Float32Array([0.12,1.123]);
+	const array2=new Float32Array([0.12,1.125]);
+	it("length mismatch", function(done){
+		assert.throws(()=>arrayl.compareToPrecision(array1,2))
+		done();
+	});
+	it("vector precision 2", function(done){
+		assert.doesNotThrow(()=>array1.compareToPrecision(array2,2))
+		done();
+	});
+	it("vector precision 3", function(done){
+		assert.throws(()=>array1.compareToPrecision(array2,3))
+		done();
+	});
+});	
+describe('pca', function(){
+	const PCA=require("../dataAnalysis/pca.js");
+	const pca=new PCA();
+	it("getMatrix", function(done){
+		assert.equal(JSON.stringify(pca.getMatrix(2,2,1)),"[[1,1],[1,1]]")
+		done();
+	})
+	it("multipe ", function(done){
+		assert.equal(JSON.stringify(pca.multiply([[1,2],[3,4],[5,1]],[[2],[4]]))
+			,JSON.stringify([[10],[22],[14]]));
+		done();
+	})
+	it("transpose ", function(done){
+		assert.equal(JSON.stringify(pca.transpose([[1,2],[3,4],[5,1]],[[2],[4]]))
+			,JSON.stringify([[1,3,5],[2,4,1]]));
+		done();
+	})
+	it("x 1 matrices", function(done){
+		assert.equal(JSON.stringify(pca.multiply(m2x2,pca.getMatrix(2,1,1))),JSON.stringify([[23],[43]]));
+		assert.equal(JSON.stringify(pca.multiply(m2x2,pca.getMatrix(2,2,1))),JSON.stringify([[23,23],[43,43]]));
+		assert.equal(JSON.stringify(pca.multiply(m2x3,pca.getMatrix(3,3,1))),JSON.stringify([[36,36,36],[66,66,66]]));
+		done();
+	})
+	const generateVectorFunction=require("../dataAnalysis/generateVectorFunction.js");
+	const generateMatrixFunction=require("../dataAnalysis/generateMatrixFunction.js");
+
+	it("multiplyMatrix", function(done){
+		const sumVector=generateVectorFunction({
+			code:"returnValue+=vector[index]*matrix[index][column]; console.log({row:index,column:column,returnValue:returnValue})",
+			args:["matrix","column"],
+			returnValue:"0"
+		})
+		const multiplyMatrix=generateMatrixFunction({
+			code:"setElement(sumVector(element,bMatrix,columnOffset));",
+			args:["bMatrix"],
+			sumVector:sumVector,
+			returnValue:"()=>getMatrix()"
+		})
+		const matrix=[[1,2],[3,4],[5,6]];
+		console.log(multiplyMatrix(matrix,3,2,[[1,1],[1,1]]));
+		done();
+	})
+});

package/test/dataAnalysisPCA.js

@@ -0,0 +1,54 @@
+const assert=require('assert');
+const should=require("should");
+require("../dataAnalysis/arrayCompareToPrecision.js");
+const PCA=require("../dataAnalysis/pca.js");
+const pca=new PCA();
+
+const m2x2=[[11,12],[21,22]]
+const m2x3=[[11,12,13],[21,22,23]]
+
+describe('pca', function(){
+	it("getMatrix", function(done){
+		assert.equal(JSON.stringify(pca.getMatrix(2,2,1)),"[[1,1],[1,1]]")
+		done();
+	})
+	it("multipe ", function(done){
+		assert.equal(JSON.stringify(pca.multiply([[1,2],[3,4],[5,1]],[[2],[4]]))
+			,JSON.stringify([[10],[22],[14]]));
+		done();
+	})
+	it("transpose ", function(done){
+		assert.equal(JSON.stringify(pca.transpose([[1,2],[3,4],[5,1]],[[2],[4]]))
+			,JSON.stringify([[1,3,5],[2,4,1]]));
+		done();
+	})
+	it("x 1 matrices", function(done){
+		assert.equal(JSON.stringify(pca.multiply(m2x2,pca.getMatrix(2,1,1))),JSON.stringify([[23],[43]]));
+		assert.equal(JSON.stringify(pca.multiply(m2x2,pca.getMatrix(2,2,1))),JSON.stringify([[23,23],[43,43]]));
+		assert.equal(JSON.stringify(pca.multiply(m2x3,pca.getMatrix(3,3,1))),JSON.stringify([[36,36,36],[66,66,66]]));
+		done();
+	})
+	it("getEigenVectors", function(done){
+		const data = [[40,50,60],[50,70,60],[80,70,90],[50,60,80]];
+		const expected=
+ [{
+     "eigenvalue": 520.0992658908312,
+     "vector": [0.744899700771276, 0.2849796479974595, 0.6032503924724023]
+ }, {
+     "eigenvalue": 78.10455398035167,
+     "vector": [0.2313199078283626, 0.7377809866160473, -0.6341689964277106]
+ }, {
+     "eigenvalue": 18.462846795484058,
+     "vector": [0.6257919271076777, -0.6119361208615616, -0.4836513702572988]
+ }];
+		const expectedEigenvalues=expected.map(element=>element.eigenvalue);
+		const expectedVectors=expected.map(element=>element.vector);
+		const result = pca.getEigenVectors(data);
+ 		console.log(result);
+		const eigenvalues=result.map(element=>element.eigenvalue);
+		const vectors=result.map(element=>element.vector);
+		expectedEigenvalues.compareToPrecision(eigenvalues,6);
+		expectedVectors.compareToPrecision(vectors,6);
+		done();
+	});
+});	

package/test/dataAnalysisSVD.js

@@ -0,0 +1,31 @@
+const assert=require('assert');
+const should=require("should");
+const svd=require("../dataAnalysis/svd.js");
+require("../dataAnalysis/arrayCompareToPrecision.js");
+
+const expected={
+	orthonormalizedColumns: [
+	  [ -0.3913289321676804, 0.3487948014410755, 0.10448989927485411 ],
+	  [ -0.4639397307294648, -0.34948424610207607, 0.7962721013609022 ],
+	  [ -0.6197155556759748, -0.5188940242462491, -0.5888137410546312 ],
+	  [ -0.4975683100363125, 0.6978194177691509, -0.0912742016622088 ]
+	],
+	singularValues: [ 223.85445199527607, 13.695880509722402, 17.366841363876695 ],
+	orthogonalMatrix: [
+	  [ -0.5061583666044986, -0.7405855572048029, -0.44196916224541927 ],
+	  [ -0.5596333427471312, -0.10788454127728717, 0.8216881692217926 ],
+	  [ -0.6562120309792694, 0.6632450212500965, -0.35984970777398323 ]
+	]
+  }
+
+describe('SVD', function(){
+	it("getEigenVectors", function(done){
+		const data = [[40,50,60],[50,70,60],[80,70,90],[50,60,80]];
+		const vectors = svd(data);
+		console.log(vectors)
+		vectors.orthonormalizedColumns.compareToPrecision(expected.orthonormalizedColumns)
+		vectors.singularValues.compareToPrecision(expected.singularValues)
+		vectors.orthogonalMatrix.compareToPrecision(expected.orthogonalMatrix)
+		done();
+	});
+});	

package/test/euclideanDistance.js

@@ -1,8 +1,8 @@
-const assert=require('assert');
+onst assert=require('assert');
 const should=require("should");
 const ed=require("../dataAnalysis/euclideanDistance.js");
 require("../dataAnalysis/forNestedEach");
-
+c
 describe('euclideanDistance', function() { 
 	it("array forNestedEach", function(done) {
 		const atest=[1,2,3,4];

package/test/matrix/02base.js

@@ -0,0 +1,36 @@
+const assert=require('assert');
+const Matrix=require("../../matrix/matrix");
+
+const m22=new Matrix([[1,2],[3,4]]);
+const m44=new Matrix([
+	[ 1, 0, 2, -1 ],
+	[ 3, 0, 0, 5 ],
+	[ 2, 1, 4, -3 ],
+	[ 1, 0, 5, 0 ]]);
+
+describe("matrix 02base", function() {
+	it('norm', function(done) {
+        const m=new Matrix([[2,3,-1], [0,-1,4]])
+        assert.strictEqual(m.norm(),5.5677643628300215); 
+		done();
+    });
+	it('norm', function(done) {
+        const m=new Matrix({rows:4,columns:4});
+        assert.doesNotThrow(()=>m.setRunningSum().equalsNearly([
+                                                [1,0,0,0],
+                                                [1,1,0,0],
+                                                [1,1,1,0],
+                                                [1,1,1,1]]));
+		done();
+    });
+	it('getVandermonde', function(done) {
+        const m=(new Matrix(1,1)).getVandermonde([-1,0,0.5,1],5);
+        assert.doesNotThrow(()=>m.equalsNearly([
+            [ 1. , -1. , 1. , -1. , 1. ],
+            [ 1. , 0. , 0. , 0. , 0. ],
+            [ 1. , 0.5 , 0.25 , 0.125 , 0.0625],
+            [ 1. , 1. , 1. , 1. , 1. ]]));
+		done();
+    });
+
+});