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

package/matrix/matrix.js

@@ -1,8 +1,54 @@
 const logger = new (require("node-red-contrib-logger"))("Matrix");
 logger.sendInfo("Copyright 2022 Jaroslav Peter Prib");
 
+const typedArrays= {Array:Array,Int8Array:Int8Array,Uint8Array:Uint8Array,Uint8ClampedArray:Uint8ClampedArray,Int16Array:Int16Array,Uint16Array:Uint16Array,
+  Int32Array:Int32Array,Uint32Array:Uint32Array,Float32Array:Float32Array,
+  Float64Array:Float64Array,BigInt64Array:BigInt64Array,BigUint64Array:BigUint64Array}
+
+  Object.keys(typedArrays).map(t=>typedArrays[t]).forEach(object=>{
+    if(object.prototype.setAll==null)
+        Object.defineProperty(object.prototype, "setAll", {
+            value(call,size=this.length) {
+                let i=size
+                while(i) this[--i]=call();
+                return this;
+            },
+            writable: true,
+            configurable: true
+        })
+	if(object.prototype.setOne==null)
+			Object.defineProperty(object.prototype, "setOne", {
+				value(call,size=this.length) {
+					let i=size
+					while(i) this[--i]=1;
+					return this;
+				},
+				writable: true,
+				configurable: true
+			})
+	if(object.prototype.setZero==null)
+        Object.defineProperty(object.prototype, "setZero", {
+            value(call,size=this.length) {
+                let i=size
+                while(i) this[--i]=0;
+                return this;
+            },
+            writable: true,
+            configurable: true
+        })
+    if(object.prototype.setRandom==null)
+        Object.defineProperty(object.prototype, "setRandom", {
+            value(size=this.length) {
+				return this.setAll(Math.random,size)
+            },
+            writable: true,
+            configurable: true
+        })
+})
+
 const zeroFloat32Value=1e-6;
-function Matrix(rows,columns,fill) {
+function Matrix(rows,columns,fill,dataType="Float32Array") {
+	this.dataType=dataType
 	if(rows instanceof Array) {
 		this.rows=rows.length;
 		if(this.rows==0) throw Error("expected rows")
@@ -15,11 +61,19 @@ function Matrix(rows,columns,fill) {
 	} 
 	if(rows instanceof Object) {
 		Object.assign(this,rows);
+		this.dataType??="Float32Array"
 	} else {
 		this.rows=rows;
 		this.columns=columns;
 	}
+	if(this.columns) this.columns=parseInt(this.columns);
+	if(this.rows)this.rows=parseInt(this.rows)
+	if(this.rowsMax) this.rowsMax=parseInt(this.rowsMax)
 	this.createVector();
+	if(fill) {
+		if(fill instanceof Function) this.setAll(fill)
+		else this.vector.set(fill)
+	}  
 	return this;
 }
 Matrix.prototype.add=function(matrix){
@@ -52,7 +106,7 @@ Matrix.prototype.addRow2Row=function(rowA,rowB,factor=1,startColumn=0,endColumn=
 	return this;
 }
 Matrix.prototype.backwardSubstitution=function(){
-	const vector=new Float32Array(this.rows);
+	const vector=new typedArrays[this.dataType](this.rows);
 	for(let row=this.rows-1; row>=0; row--) {
 		vector[row] = this.get(row,this.rows);
 		for(let column=row+1; column<this.rows; column++)	{
@@ -101,15 +155,17 @@ Matrix.prototype.createVector=function(){
 			this.sizeMax=this.rowsMax*this.columns;
 		}
 		if(this.columns==null) throw Error("columns not specified")
-		this.size=this.rows*this.columns
-		if(this.sizeMax==null) this.sizeMax=this.size
 	} else {
 		if(this.columns==null) throw Error("columns not specified")
+		if(this.columns==0) throw Error("columns = 0")
 		if(this.rows==null){
 			this.rows=0;
 		}  	
 	}
-	this.vector=new Float32Array(this.sizeMax);
+	this.size=this.rows*this.columns
+	if(this.sizeMax==null) this.sizeMax=this.size
+	if(this.sizeMax==null) throw Error("max size not specified or calculated")
+	this.vector=new typedArrays[this.dataType](this.sizeMax);
 	return this;
 }
 Matrix.prototype.divideCell=function(row,column,value){
@@ -472,7 +528,6 @@ Matrix.prototype.multiplyRow=function(row,factor){
 	return this;
 }
 Matrix.prototype.norm=function(){
-
 	return Math.sqrt(this.reduce((aggregate,cell)=>aggregate+cell*cell))
 }
 Matrix.prototype.reduce=function(call,aggregate=0){
@@ -560,17 +615,48 @@ Matrix.prototype.set=function(row,column,value){
 	this.vector[this.getIndex(row,column)]=value;
 	return this;
 }
+Matrix.prototype.setAll=function(call){
+	for(let offset=0,row=0;row<this.rows;row++) {
+		for(let column=0;column<this.columns;column++) {
+			this.vector[offset]=call.apply(this,[row,column,this.vector[offset],this.vector,offset,this]);
+			offset++
+		}
+	}
+	this.rows=this.rowsMax
+	this.size=this.sizeMax
+	return this;
+}
 Matrix.prototype.setDeterminant=function(){
 	this.determinant=this.getDeterminantUsingRowEchelonForm();
 	return this.determinant;
 }
+Matrix.prototype.setIdentity=function(){
+	if(this.columns!=this.rowsMax) throw Error("number of columns not equal rows")
+	this.setZero()
+	for(let offset=0;offset<this.size;offset+=this.columns+1) this.vector[offset]=1;
+	return this;
+}
+Matrix.prototype.setWithFunction=function(f){
+	this.vector[f](this.sizeMax)
+	this.rows=this.rowsMax
+	this.size=this.sizeMax;
+	return this;
+}
+Matrix.prototype.setOne=function(){
+    return this.setWithFunction("setOne")
+}
+Matrix.prototype.setRandom=function(){
+    return this.setWithFunction("setRandom")
+}
 Matrix.prototype.setRow=function(vector,row){
 	this.vector.set(vector, row*this.columns);
 	return this;
 }
 Matrix.prototype.setRunningSum=function(){
 	this.forEachCellLowerTriangle((cell,row,column,vector,offset,object)=>vector[offset]=1);
-	return this;
+}
+Matrix.prototype.setZero=function(){
+	return this.setWithFunction("setZero")
 }
 Matrix.prototype.substract=function(matrix){
 	this.forEachCellPairSet(matrix,(cellA,cellB)=>cellA-cellB)
@@ -610,5 +696,4 @@ Matrix.prototype.transpose=function(){
 	this.forEachCell((cell,row,column)=>matrix.set(column,row,cell))
 	return matrix;
 }
-
 module.exports=Matrix;

package/matrix/matrixNode.html

@@ -7,18 +7,20 @@
 			name: {value:null},
 			action: {value: "create",required:true},
 			args: {value:[]},
-			arg: {value:null},"arg-type": {value:"msg"},
 			call:{value:null},
-			column: {value:null},"column-type": {value:"num"},
-			columns: {value:null},"columns-type": {value:"num"},
+			column: {value:2},"column-type": {value:"num"},
+			columns: {value:2},"columns-type": {value:"num"},
+			dataType: {value:"Float32Array"},"columns-type": {value:"Float32Array"},
 			end: {value:null},"end-type": {value:"num"},
 			factor: {value:null},"factor-type": {value:"num"},
+			initialState:{value:"setZero"},
 			matrix: {value:"payload"},"matrix-type": {value:"msg"},
 			precision: {value:3},"precision-type": {value:"num"},
 			row: {value:3},"row-type": {value:"num"},
 			rows: {value:3},"rows-type": {value:"num"},
 			rowTarget: {value:null},"rowTarget-type": {value:"num"},
 			source: {value:"_matrix"},"source-type": {value:"msg"},
+			sourceArray: {value:"payload"},"sourceArray-type": {value:"msg,json,flow,global"},
 			start: {value:null},"start-type": {value:"num"},
 			target: {value:"_matrix"},"target-type": {value:"msg"},
 			value: {value:"payload"},"value-type": {value:"msg"},
@@ -35,70 +37,70 @@
 			return this.name || ("Matrix "+this.action||"*** new ***");
 		},
 		oneditprepare: function() {
+			console.log("+++")
 			const node=this;
 			node.properties=[];
 			node.editors=[];
 			const actions={
-				define:{label:"Define",show:["target"],args:["rows","columns"]},
-				defineEmpty:{label:"Define Empty",show:["target"],args:["rows","columns"]},
-				create:{label:"Create",show:["target"],args:[]},
-                createLike:{label:"Create Like",show:["source","target"],args:[]},
-                clone:{label:"Clone",show:["source","target"],args:[]},
                 add:{label:"Add",show:["source"],args:["matrix"]},
                 addRow:{label:"Add Row",show:["source"],args:["row","vector"]},
 				addRow2Row:{label:"Add Row to Row",show:["source"],args:["row","target","factor","start","end"]},
                 addCell:{label:"Add to Cell",show:["source"],args:["row","column","value"]},
-                subtractCell:{label:"Subtract Cell",show:["source","target"],args:["row","column","value"]},
-                multiple:{label:"Multiple",show:["source","target"],args:[]},
-                multipleCell:{label:"Multiple Cell",show:["source","target"],args:["rows","columns","value"]},
-                divideCell:{label:"Divide Cell",show:["source"],args:["rows","columns","value"]},
-                divideRow:{label:"Divide Row",show:["source"],args:["row","factor","start","end"]},
-                transpose:{label:"Transpose",show:["source","target"],args:[]},
-                getAdjoint:{label:"Adjoint",show:["source","target"],args:[]},
-                getCofactor:{label:"Cofactor",show:["source","target"],args:[]},
-                getComplementMinor:{label:"Complement Minor",show:["source","target"],args:[]},
-				getIdentity:{label:"Identity",show:["source","target"],args:[]},
-				getInverse:{label:"Inverse",show:["source","target"],args:[]},
-				getInverseAdjointMethod:{label:"Inverse (Adjoint Method)",show:["source","target"],args:[]},
-				getInverseGaussJordan:{label:"Inverse (Gauss Jordan Method)",show:["source","target"],args:[]},
-				norm:{label:"Norm",show:["source","target"],args:[]},
-				getDeterminant:{label:"Determinant",show:["source","target"],args:[]},
-				getDeterminantUsingCofactor:{label:"Determinant (Cofactor)",show:["source","target"],args:[]},
-				getDeterminantUsingCofactor:{label:"Determinant (Row Echelon Form)",show:["source","target"],args:[]},
                 backwardSubstitution:{label:"Backward Substitution",show:["source"],args:[]},
-				forwardElimination:{label:"Forward Elimination",show:["source"],args:[]},
-				gaussianElimination:{label:"Gaussian Elimination",show:["source"],args:[]},
-				reducedRowEchelonForm:{label:"Reduced Row EchelonForm",show:["source"],args:[]},
-				rowEchelonForm:{label:"Row Echelon Form",show:["source"],args:[]},
-                equalsNearly:{label:"Nearly Equals",show:["source"],args:[]},
-				testIsSquare:{label:"Is Square",show:["source"],args:[]},
-				get:{label:"Get Cell",show:["source","target"],args:[]},
-				sumRow:{label:"Sum Row",show:["source","target"],args:[]},
-				swapRows:{label:"Swap Rows",show:["source"],args:[]},
-				toArray:{label:"To Array Object",show:["source","target"],args:[]},
-				runningSum:{label:"Running Sum",show:["source","target"],args:[]},
-				getVandermonde:{label:"Vandermonde",show:["target"],args:["vector","columns"]},
-				create:{label:"Create",show:[,"target"],args:["rows","columns"]},
+				create:{label:"Create",         show:["target"],args:["initialState","rows","columns","dataType"]},
+                createLike:{label:"Create Like",show:["source","target"],args:[]},
+                clone:{label:"Clone",show:["source","target"],args:[]},
 				createForEachCellPairSet:{label:"Create Pair Set Cells",show:["source","target"],args:["matrix","call"],default:{call:"(baseCellValue,matrixCellValue)=>{}"}},
+				define:{label:"Define",show:["target"],args:["rows","columns","dataType"]},
+				defineEmpty:{label:"Define Empty",show:["target"],args:["rows","columns","dataType"]},
+				divideCell:{label:"Divide Cell",show:["source"],args:["rows","columns","value"]},
+                divideRow:{label:"Divide Row",show:["source"],args:["row","factor","start","end"]},
+                equalsNearly:{label:"Nearly Equals",show:["source"],args:[]},
+				fillArray:{label:"Fill",show:["source"],args:["matrix"]},
+				findColumnRow:{label:"Find in Column",show:["source"],args:["column","call","start","end"],default:{call:"()=>{}"}},
 				findRowColumn:{label:"Find in Row",show:["source"],args:["row","call","start","end"],default:{call:"(value,row,column,offset,vector)=>true"}},
 				forRowCells:{label:"Row Cells",show:["source"],args:["row","call","start","end"],default:{call:"()=>{}"}},
-				fillArray:{label:"fill",show:["source"],args:["matrix"]},
-				findColumnRow:{label:"Find in Column",show:["source"],args:["column","call","start","end"],default:{call:"()=>{}"}},
 				forColumnCells:{label:"Column Cells",show:["source"],args:["column","call","start","end"],default:{call:"()=>{}"}},
 				forEachCell:{label:"For Each Cell",show:["source"],args:["call"],default:{call:"()=>{}"}},
 				forEachRow:{label:"For Each Row",show:["source"],args:["call"],default:{call:"()=>{}"}},
 				forEachCellPairSet:{label:"For Each Cell Pair Set",show:["source"],args:["matrix","call"],default:{call:"()=>{}"}},
+				forwardElimination:{label:"Forward Elimination",show:["source"],args:[]},
+				gaussianElimination:{label:"Gaussian Elimination",show:["source"],args:[]},
+				get:{label:"Get Cell",show:["source","target"],args:[]},
+                getAdjoint:{label:"Adjoint",show:["source","target"],args:[]},
+                getCofactor:{label:"Cofactor",show:["source","target"],args:[]},
+                getComplementMinor:{label:"Complement Minor",show:["source","target"],args:[]},
+				getDeterminant:{label:"Determinant",show:["source","target"],args:[]},
+				getDeterminantUsingCofactor:{label:"Determinant (Cofactor)",show:["source","target"],args:[]},
+				getDeterminantUsingCofactor:{label:"Determinant (Row Echelon Form)",show:["source","target"],args:[]},
+				getIdentity:{label:"Identity",show:["source","target"],args:[]},
+				getInverse:{label:"Inverse",show:["source","target"],args:[]},
+				getInverseAdjointMethod:{label:"Inverse (Adjoint Method)",show:["source","target"],args:[]},
+				getInverseGaussJordan:{label:"Inverse (Gauss Jordan Method)",show:["source","target"],args:[]},
 				getIndex:{label:"Get Vector Offset",show:["source","target"],args:["row","column"]},
-				getZeroed:{label:"Get Zeroed",show:["source","target"],args:["row","column"]},
-				getMatrix:{label:"get Sub Matrix",show:["source","target"],args:["row","column","rows","columns"]},
+				getMatrix:{label:"Get Sub Matrix",show:["source","target"],args:["row","column","rows","columns"]},
 				getRow:{label:"Get Row",show:["source","target"],args:["row"]},
+				getVandermonde:{label:"Vandermonde",show:["target"],args:["vector","columns"]},
+				getZeroed:{label:"Get Zeroed",show:["source","target"],args:["row","column"]},
 				maxAbsColumn:{label:"Column Maximum Absolute",show:["source","target"],args:["column","start"]},
 				maxColumn:{label:"Column Max",show:["source","target"],args:["column","start"]},
+                multiple:{label:"Multiple",show:["source","target"],args:[]},
+                multipleCell:{label:"Multiple Cell",show:["source","target"],args:["rows","columns","value"]},
 				multiplyRow:{label:"Multiply Row",show:["source"],args:["row","factor"]},
+				norm:{label:"Norm",show:["source","target"],args:[]},
 				reduceRow:{label:"Reduce Row",show:["source","target"],args:["row","call","value"],default:{call:"(agregatevalue,cellValue,row,column)=>agregatevalue+cellValue"}},
+				reduce:{label:"Reduce Cells",show:["source","target"],args:["call","value"],default:{call:"()=>{}"}},
+				reducedRowEchelonForm:{label:"Reduced Row EchelonForm",show:["source"],args:[]},
+				rowEchelonForm:{label:"Row Echelon Form",show:["source"],args:[]},
+				runningSum:{label:"Running Sum",show:["source","target"],args:[]},
 				set:{label:"Set Cell",show:["source"],args:["row","column","value"]},
 				setRow:{label:"Set Row",show:["source"],args:["vector","row"]},
-				reduce:{label:"Reduce Cells",show:["source","target"],args:["call","value"],default:{call:"()=>{}"}}
+                subtractCell:{label:"Subtract Cell",show:["source","target"],args:["row","column","value"]},
+				sumRow:{label:"Sum Row",show:["source","target"],args:[]},
+				swapRows:{label:"Swap Rows",show:["source"],args:[]},
+				testIsSquare:{label:"Is Square",show:["source"],args:[]},
+				toArray:{label:"To Array Object",show:["source","target"],args:[]},
+                transpose:{label:"Transpose",show:["source","target"],args:[]}
 			};
 			const baseDiv=$("#node-inputDynamicBase");
 			function defineProperty(property,...types) {
@@ -118,16 +120,46 @@
 					const inputNode=$('<input type="text" id="node-input-'+property.name+'"/>').val(node[property.name]);
 					const typeNode=$('<input type="hidden" id="node-input-'+property.name+'-type"/>');
 					element.append([inputNode,typeNode]);
-					const typeValue=node[property.name+"-type"];
-					if(typeValue) typeNode.val(typeValue);
-					$("#node-input-"+property.name).typedInput({
-	  					type:typeValue||types[0],
-    					types:types,
-    					typeField: "#node-input-"+property.name+"-type"
-					});
+					if(types[0] instanceof Array) {
+						$("#node-input-"+property.name).typedInput({
+							type:property.name, 
+							types:[{value: property.name,
+    							options: types[0]
+							}]})
+					} else {
+						const typeValue=node[property.name+"-type"];
+					    if(typeValue) typeNode.val(typeValue);
+						$("#node-input-"+property.name).typedInput({
+	  						type:typeValue||types[0],
+    						types:types,
+    						typeField: "#node-input-"+property.name+"-type"
+						});
+					}
 				}
 			}
-			defineProperty({name:"source"	,label:"Source"		,icon:"crosshairs"},"msg","flow","global");
+			defineProperty({name:"initialState",label:"Initially"	,icon:"tag"},[
+        		{ value: "setZero", label: "Zeros"},
+        		{ value: "setRandom", label: "Random Numbers"},
+        		{ value: "setIdentity", label: "Identity"},
+				{ value: "setOne", label: "all 1"},
+				]);
+
+			defineProperty({name:"dataType",label:"number Type"	,icon:"tag"},[
+				{ value: "Float32Array", label: "float32	-3.4e38 to 3.4e38" },
+				{ value: "Float64Array", label: "double/float64	-1.8e308 to 1.8e308" },				{ value: "Int8Array", label: "byte -128 to 122" },
+				{ value: "Uint8Array", label: "octet 0 to 255" },
+				{ value: "Uint8ClampedArray", label: "octet clamped 0 to 255" },
+				{ value: "Int16Array", label: "short -32768 to 32767" },
+				{ value: "Uint16Array", label: "short unsigned  0 to 65535" },
+				{ value: "Int32Array", label: "	long -2147483648 to 2147483647" },
+				{ value: "Uint32Array", label: "long unsgined 0 to 4294967295" },
+				{ value: "BigInt64Array", label: "bigint 2**-263 to 2**263" },
+				{ value: "BigUint64Array", label: "bigint unsigned 0 to 2**264" },
+			]);
+
+
+
+			defineProperty({name:"source"	,label:"Source"		,icon:"crosshairs"},"msg","json","flow","global");
 			defineProperty({name:"arg"		,label:"Argument"	,icon:"tag"},"num","json","msg","flow","global","env");
 			defineProperty({name:"matrix"	,label:"Matrix"		,icon:"th"},"msg","flow","global");
 			defineProperty({name:"target"	,label:"Target"		,icon:"save"},"msg","flow","global");
@@ -145,8 +177,10 @@
 			defineProperty({name:"vector"	,label:"Vector"		,icon:"ellipsis-h"},"json","msg","flow","global");
 			defineProperty({name:"call"		,label:"Call"		,icon:"js",mode:"javascript"},"edit");
 
-			const options=Object.keys(actions).reduce((previousValue,property)=>previousValue.concat({value:property,label:actions[property].label}),
-				[]);
+			const options=Object.keys(actions)
+				.sort((a,b) => actions[a].label<actions[b].label?-1:0)
+				.reduce((previousValue,property)=>previousValue.concat({value:property,label:actions[property].label}),
+					[]);
 			const actionNode=$("#node-input-action");
 			actionNode.typedInput({
     			types: [{
@@ -154,7 +188,7 @@
             		options: options
 				}]
 			});
-	actionNode.change(function() {
+			actionNode.change(function() {
 				action=$(this).val();
 				node.args=[];
 				node.properties.forEach(property=>$(".form-row-http-in-"+property).hide());
@@ -162,7 +196,6 @@
 				node.args=actionDef.args;
 				node.args.forEach(property=>$(".form-row-http-in-"+property).show());
 				actionDef.show.forEach(property=>$(".form-row-http-in-"+property).show());
-
 			});
 		},
 		oneditsave: function() {

package/matrix/matrixNode.js

@@ -23,6 +23,7 @@ function evalInFunction(node,propertyName){
 		const property=node[propertyName];
 		if(property==null) throw Error("no value for "+propertyName);
 		const propertyType=propertyName+"-type";
+		if(! (propertyType in node)) return evalFunction(propertyName,"()=>node."+property) 
 		switch (node[propertyType]){
 		case "num":
 		case "json":
@@ -86,7 +87,11 @@ module.exports = function (RED) {
 			}	
 			node.argFunction=[];
 			node.args.forEach(property=>{
-				node.argFunction.push(evalInFunction(node,property).bind(this));
+				try{
+					node.argFunction.push(evalInFunction(node,property).bind(this));
+				} catch(ex) {
+					throw Error("args "+property+" "+ex.message)
+				}
 			})
 			function baseProcess(msg){
 				const sourceIn=node.getSource(msg);
@@ -99,14 +104,15 @@ module.exports = function (RED) {
 				node.setData.apply(node,[result,msg]);
 			}
 			function createProcess(msg){
-				const sourceIn=node.getSource(msg);
-				if(sourceIn==null) throw Error("source data not found");
-				const sourceMatrix=(sourceIn instanceof Matrix?sourceIn.clone():new Matrix(sourceIn));
+				if(logger.active) logger.sendInfo({label:"create",arg:{rowsMax:node.row,columns:node.column}});
+				const sourceMatrix=new Matrix({rowsMax:node.rows,columns:node.columns,dataType:node.dataType});
+				if(!(node.initialState in sourceMatrix)) throw Error("Invalid initial state "+node.initialState);
+				sourceMatrix[node.initialState]()
 				node.setData.apply(node,[sourceMatrix,msg]);
 			}
 			function defineProcess(msg){
 				if(logger.active) logger.sendInfo({label:"define",arg:{rows:node.row,columns:node.column}});
-				const sourceMatrix=new Matrix({rows:node.rows,columns:node.columns});
+				const sourceMatrix=new Matrix({rows:node.rows,columns:node.columns,dataType:node.dataType});
 				node.setData.apply(node,[sourceMatrix,msg]);
 			}
 			function defineEmptyProcess(msg){
@@ -152,6 +158,7 @@ module.exports = function (RED) {
 				node.msgProcess(msg);
 				node.send(msg);
 			} catch(ex) {
+				error(node,ex,"Invalid "+ex.message)
 				msg.error=ex.message;
 				node.send([null,msg]);
 				if(logger.active) logger.send({label:"error",node:node.id,action:node.action,exception:ex.message,stack:ex.stack});

package/monitor/monitorSystem.html

@@ -44,6 +44,7 @@
             )
         } catch(ex) {
             svgUpdate=false
+            if(ex.message.startsWith("element id not found")) return
             console.error(ex.message + " for "+JSON.stringify(nodeDetails[id]))
         }
     }
@@ -79,7 +80,7 @@
         outputLabels: ["out"],
         icon: "icons8-heart-monitor-40.png",
         label: function() {
-            console.error("*****+++++")
+            console.log("*****+++++")
             if(!nodeSvg.hasOwnProperty(this.id)) {
                 nodeSvg[this.id]={element:document.getElementById(this.id),actions:[{action:"text",x:0 ,y:60 ,children:["Waiting Refresh"]}]}
             }

package/monitor/monitorSystem.js

@@ -155,7 +155,7 @@ let metrics=[]
 const nodes=[]
 function getJson(){
     return nodes.reduce((p,node)=>{
-        p[node.id]=node.getSendData(metrics[0])
+        p[node.id]=metrics.length?node.getSendData(metrics[0]):null
         return p;
     },{})
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-red-contrib-prib-functions",
-	"version": "0.20.4",
+	"version": "0.22.0",
 	"description": "Node-RED added node functions.",
 	"dependencies": {
 		"avsc": ">=5.7.7",
@@ -38,9 +38,13 @@
 		"adjoint",
 		"append",
 		"analysis",
+		"autocorrelation",
+		"autocovariance",
 		"average",
 		"avg",
 		"AVRO",
+		"arima",
+		"ARMIA",
 		"arvo",
 		"backward substitution",
 		"compare",

package/test/data/.config.nodes.json

@@ -448,7 +448,7 @@
     },
     "node-red-contrib-prib-functions": {
         "name": "node-red-contrib-prib-functions",
-        "version": "0.20.2",
+        "version": "0.22.0",
         "local": true,
         "user": true,
         "nodes": {

package/test/data/.config.nodes.json.backup

@@ -1,7 +1,7 @@
 {
     "node-red": {
         "name": "node-red",
-        "version": "3.1.11",
+        "version": "3.1.14",
         "local": false,
         "user": false,
         "nodes": {
@@ -448,7 +448,7 @@
     },
     "node-red-contrib-prib-functions": {
         "name": "node-red-contrib-prib-functions",
-        "version": "0.20.2",
+        "version": "0.21.0",
         "local": true,
         "user": true,
         "nodes": {