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

package/test/data/package-lock.json

@@ -0,0 +1,158 @@
+{
+    "name": "node-red-project",
+    "version": "0.0.1",
+    "lockfileVersion": 3,
+    "requires": true,
+    "packages": {
+        "": {
+            "name": "node-red-project",
+            "version": "0.0.1",
+            "dependencies": {
+                "node-red-contrib-prib-functions": "file:../..",
+                "node-red-node-data-generator": "~1.0.1",
+                "node-red-project": "file:"
+            }
+        },
+        "../..": {
+            "version": "0.20.4",
+            "license": "GPL-3.0",
+            "dependencies": {
+                "avsc": ">=5.7.7",
+                "compressiontool": "*",
+                "fast-xml-parser": "^4.2.5",
+                "node": ">=0.6.13",
+                "node-red-contrib-logger": "latest",
+                "node-red-contrib-noderedbase": ">=0.0.16",
+                "node-red-contrib-prib-functions": "file:",
+                "npm": "^10.9.0",
+                "xlsx": "*"
+            },
+            "devDependencies": {
+                "@node-red/runtime": ">=1.2.8",
+                "axios": ">=0.21.1",
+                "bcrypt": "^5.0.1",
+                "bl": "^5.0.0",
+                "mocha": "^9.2.2",
+                "node-red": "^3.0.2",
+                "node-red-node-test-helper": "^0.3.0"
+            }
+        },
+        "node_modules/bignumber.js": {
+            "version": "8.1.1",
+            "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-8.1.1.tgz",
+            "integrity": "sha512-QD46ppGintwPGuL1KqmwhR0O+N2cZUg8JG/VzwI2e28sM9TqHjQB10lI4QAaMHVbLzwVLLAwEglpKPViWX+5NQ==",
+            "engines": {
+                "node": "*"
+            }
+        },
+        "node_modules/dummy-json": {
+            "version": "3.0.5",
+            "resolved": "https://registry.npmjs.org/dummy-json/-/dummy-json-3.0.5.tgz",
+            "integrity": "sha512-g+DRLULk7jOqnFEZGBKJ4S0EiFqZETkof4V954I9Xoftq/g728Qf3D7TVmgboW1Y7ROe2Y+cZzUDAYstNqXwsg==",
+            "dependencies": {
+                "fecha": "^3.0.3",
+                "handlebars": "^4.7.6",
+                "numbro": "^2.3.1",
+                "seedrandom": "^3.0.5"
+            },
+            "bin": {
+                "dummyjson": "cli.js"
+            }
+        },
+        "node_modules/fecha": {
+            "version": "3.0.3",
+            "resolved": "https://registry.npmjs.org/fecha/-/fecha-3.0.3.tgz",
+            "integrity": "sha512-6LQK/1jud/FZnfEEZJ7y81vw7ge81DNd/XEsX0hgMUjhS+QMljkb1C0czBaP7dMNRVrd5mw/J2J7qI2Nw+TWZw=="
+        },
+        "node_modules/handlebars": {
+            "version": "4.7.8",
+            "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.7.8.tgz",
+            "integrity": "sha512-vafaFqs8MZkRrSX7sFVUdo3ap/eNiLnb4IakshzvP56X5Nr1iGKAIqdX6tMlm6HcNRIkr6AxO5jFEoJzzpT8aQ==",
+            "dependencies": {
+                "minimist": "^1.2.5",
+                "neo-async": "^2.6.2",
+                "source-map": "^0.6.1",
+                "wordwrap": "^1.0.0"
+            },
+            "bin": {
+                "handlebars": "bin/handlebars"
+            },
+            "engines": {
+                "node": ">=0.4.7"
+            },
+            "optionalDependencies": {
+                "uglify-js": "^3.1.4"
+            }
+        },
+        "node_modules/minimist": {
+            "version": "1.2.8",
+            "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+            "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
+        "node_modules/neo-async": {
+            "version": "2.6.2",
+            "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz",
+            "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw=="
+        },
+        "node_modules/node-red-contrib-prib-functions": {
+            "resolved": "../..",
+            "link": true
+        },
+        "node_modules/node-red-node-data-generator": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/node-red-node-data-generator/-/node-red-node-data-generator-1.0.1.tgz",
+            "integrity": "sha512-ISO7/JWzyB2MIRuASosi6PkUfAgLHVfyyk28Jqn0R2GkrgX7PCGiUBcsDOwseIAnHEtAM/1/8+LeqGV3qOYjfQ==",
+            "dependencies": {
+                "dummy-json": "^3.0.5"
+            }
+        },
+        "node_modules/node-red-project": {
+            "resolved": "",
+            "link": true
+        },
+        "node_modules/numbro": {
+            "version": "2.3.6",
+            "resolved": "https://registry.npmjs.org/numbro/-/numbro-2.3.6.tgz",
+            "integrity": "sha512-pxpoTT3hVxQGaOA2RTzXR/muonQNd1K1HPJbWo7QOmxPwiPmoFCFfsG9XXgW3uqjyzezJ0P9IvCPDXUtJexjwg==",
+            "dependencies": {
+                "bignumber.js": "^8.1.1"
+            },
+            "engines": {
+                "node": "*"
+            }
+        },
+        "node_modules/seedrandom": {
+            "version": "3.0.5",
+            "resolved": "https://registry.npmjs.org/seedrandom/-/seedrandom-3.0.5.tgz",
+            "integrity": "sha512-8OwmbklUNzwezjGInmZ+2clQmExQPvomqjL7LFqOYqtmuxRgQYqOD3mHaU+MvZn5FLUeVxVfQjwLZW/n/JFuqg=="
+        },
+        "node_modules/source-map": {
+            "version": "0.6.1",
+            "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+            "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+            "engines": {
+                "node": ">=0.10.0"
+            }
+        },
+        "node_modules/uglify-js": {
+            "version": "3.17.4",
+            "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.17.4.tgz",
+            "integrity": "sha512-T9q82TJI9e/C1TAxYvfb16xO120tMVFZrGA3f9/P4424DNu6ypK103y0GPFVa17yotwSyZW5iYXgjYHkGrJW/g==",
+            "optional": true,
+            "bin": {
+                "uglifyjs": "bin/uglifyjs"
+            },
+            "engines": {
+                "node": ">=0.8.0"
+            }
+        },
+        "node_modules/wordwrap": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz",
+            "integrity": "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q=="
+        }
+    }
+}

package/test/data/package.json

@@ -0,0 +1,11 @@
+{
+    "name": "node-red-project",
+    "description": "A Node-RED Project",
+    "version": "0.0.1",
+    "private": true,
+    "dependencies": {
+        "node-red-contrib-prib-functions": "file:../..",
+        "node-red-node-data-generator": "~1.0.1",
+        "node-red-project": "file:"
+    }
+}

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();
+	});
+});