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

package/matrix/matrixNode.html

@@ -0,0 +1,224 @@
+<script type="text/javascript">
+	/*globals RED */
+	RED.nodes.registerType('matrix', {
+		category: 'function',
+		color: '#fdeea2',
+		defaults: {
+			name: {value:null},
+			action: {value: "create",required:true},
+			args: {value:[]},
+			arg: {value:null},
+			"arg-type": {value:"msg"},
+			column: {value:null},
+			"column-type": {value:"num"},
+			end: {value:null},
+			"end-type": {value:"num"},
+			factor: {value:null},
+			"factor-type": {value:"num"},
+			precision: {value:3},
+			"precision-type": {value:"num"},
+			row: {value:3},
+			"row-type": {value:"num"},
+			rowTarget: {value:null},
+			"rowTarget-type": {value:"num"},
+			source: {value:"_matrix"},
+			"source-type": {value:"msg"},
+			matrix: {value:"payload"},
+			"matrix-type": {value:"msg"},
+			start: {value:null},
+			"start-type": {value:"num"},
+			target: {value:"_matrix"},
+			"target-type": {value:"msg"},
+			value: {value:"payload"},
+			"value-type": {value:"msg"}
+		},
+		inputs: 1,
+		outputs: 2,
+		icon: "icons8-matrix-desktop-80.png",
+		align: 'left',
+		paletteLabel: "Matrix",
+		inputLabels: "Message In",
+		outputLabels: ["Message Out","Error"],
+		label: function () {
+			return this.name || ("Matrix "+this.action||"*** new ***");
+		},
+		oneditprepare: function() {
+			const node=this;
+			let properties=[];
+			const baseDiv=$("#node-inputDynamicBase");
+			function defineProperty(property,...types) {
+				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"/>');
+				const element= $('<div/>',{ "class": "form-row form-row-http-in-"+property.name+" hide" }).append([
+    				 	$('<label for="node-input-'+property.name+'" style="white-space: nowrap"><i class="icon-'+(property.icon||'-bookmark')+'"></i> '+property.label+'</label>'),
+        				inputNode,typeNode
+    				]);
+				element.appendTo(baseDiv);
+				properties.push(property.name);
+				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:"tag"},"msg","flow","global");
+			defineProperty({name:"arg"		,label:"Argument"	,icon:"tag"},"num","json","msg","flow","global","env");
+			defineProperty({name:"matrix"	,label:"Matrix"		,icon:"tag"},"msg","flow","global");
+			defineProperty({name:"target"	,label:"Target"		,icon:"tag"},"msg","flow","global");
+			defineProperty({name:"column"	,label:"Column"		,icon:"tag"},"num","msg","flow","global");
+			defineProperty({name:"row"		,label:"Row"		,icon:"tag"},"num","msg","flow","global");
+			defineProperty({name:"value"	,label:"Value"		,icon:"tag"},"num","msg","flow","global");
+			defineProperty({name:"rowTarget",label:"Target Row"	,icon:"tag"},"num","msg","flow","global");
+			defineProperty({name:"factor"	,label:"Factor"		,icon:"tag"},"num","msg","flow","global");
+			defineProperty({name:"precision",label:"Precision"	,icon:"tag"},"num","msg","flow","global");
+			defineProperty({name:"start"	,label:"Start"		,icon:"tag"},"num","msg","flow","global");
+			defineProperty({name:"end"		,label:"End"		,icon:"tag"},"num","msg","flow","global");
+
+			const actionNode=$("#node-input-action");
+			actionNode.typedInput({
+    			types: [{
+            		value: "actionType",
+            		options: [
+						{value:"define",				label:"Define"},
+						{value:"defineEmpty",			label:"Define Empty"},
+						{value:"create",				label:"Create"},
+                		{value:"createLike",			label:"Create Like"},
+                		{value:"clone",					label:"Clone"},
+                		{value:"add",					label:"Add"},
+						{value:"addRow2Row",			label:"Add Row to Row"},
+                		{value:"addCell",				label:"Add to Cell"},
+                		{value:"addRow",				label:"Add Row"},
+                		{value:"subtractCell",			label:"Subtract Cell"},
+                		{value:"multiple",				label:"Multiple"},
+                		{value:"multipleCell",			label:"Multiple Cell"},
+                		{value:"divideCell",			label:"Divide Cell"},
+                		{value:"divideRow",				label:"Divide Row"},
+                		{value:"transpose",				label:"Transpose"},
+                		{value:"getAdjoint",			label:"Adjoint"},
+                		{value:"getCofactor",			label:"Cofactor"},
+                		{value:"getComplementMinor",	label:"Complement Minor"},
+						{value:"getIdentity",			label:"Identity"},
+						{value:"getInverse",			label:"Inverse"},
+						{value:"getInverseAdjointMethod",label:"Inverse (Adjoint Method)"},
+						{value:"getInverseGaussJordan"	,label:"Inverse (Gauss Jordan Method)"},
+						{value:"getDeterminant",		label:"Determinant"},
+						{value:"getDeterminantUsingCofactor",label:"Determinant (Cofactor)"},
+						{value:"getDeterminantUsingCofactor",label:"Determinant (Row Echelon Form)"},
+                		{value:"backwardSubstitution",	label:"Backward Substitution"},
+						{value:"forwardElimination",	label:"Forward Elimination"},
+						{value:"gaussianElimination",	label:"Gaussian Elimination"},
+						{value:"reducedRowEchelonForm",	label:"Reduced Row EchelonForm"},
+						{value:"rowEchelonForm",		label:"Row Echelon Form"},
+                		{value:"equalsNearly",			label:"Nearly Equals"},
+						{value:"testIsSquare",			label:"Is Square"},
+						{value:"get",					label:"Get Cell"},
+						{value:"sumRow",				label:"Sum Row"},
+						{value:"swapRows",				label:"Swap Rows"},
+						{value:"toArray",				label:"To Array Object"}
+            		]
+        		}]
+			});
+//Matrix.prototype.createForEachCellPairSet=function(matrix,call){
+//Matrix.prototype.findRowColumn=function(row,call,startColumn=0,endColumn=this.columns-1){
+//Matrix.prototype.forRowCells=function(row,call,startColumn=0,endColumn=this.columns-1){
+//Matrix.prototype.fillArray=function(a){
+//Matrix.prototype.findColumnRow=function(column,call,startRow=0,endRow=this.rows-1){
+//Matrix.prototype.forColumnCells=function(column,call,startRow=0,endRow=this.rows-1){
+//Matrix.prototype.forEachCell=function(call){
+//Matrix.prototype.forEachRow=function(call){
+//Matrix.prototype.forEachCellPairSet=function(matrix,call){
+//Matrix.prototype.getIndex=function(row, column){
+//Matrix.prototype.getZeroed=function(row, column){
+//Matrix.prototype.getMatrix=function(row,column,rows,columns){
+//Matrix.prototype.getRow=function(row){
+//Matrix.prototype.maxAbsColumn=function(column,startRow=0){
+//Matrix.prototype.maxColumn=function(column,startRow=0){
+//Matrix.prototype.multiplyRow=function(row,factor){
+//Matrix.prototype.reduceRow=function(row,call,value=0){
+//Matrix.prototype.set=function(row,column,value){
+//Matrix.prototype.setRow=function(vector,row){
+			actionNode.change(function() {
+				action=$(this).val();
+				let show=["source","target"];
+				node.args=[];
+				properties.forEach(property=>$(".form-row-http-in-"+property).hide());
+        		if(["forwardElimination","backwardSubstitution","gaussianElimination",
+					"reducedRowEchelonForm","rowEchelonForm","testIsSquare"].includes(action)) {
+        			show=["source"];
+				} else if(["equalsNearly"].includes(action)) {
+					show=["source"]; 
+					node.args=["matrix"];
+				} else if(["define"].includes(action)) {
+					show=["target"]; 
+					node.args=["row","column"];
+ 				} else if(["addCell","subtractCell","multiplyCell","divideCell"].includes(action)) {
+        			show=["source"];
+					node.args=["row","column","value"];
+				} else if(["get","getComplementMinor","getCofactor"].includes(action)) {
+        			show=["source","target"]; 
+					node.args=["row","column"];
+				} else if(["sumRow"].includes(action)){
+					node.args=["row"];
+				} else if(["define"].includes(action)){
+					show=["target"]; 
+					node.args=["row","column"];
+				} else if(["defineEmpty"].includes(action)){
+					show=["target"]; 
+					node.args=["row","column"];
+				} else if(["swapRows"].includes(action)){
+					show=["source"]; 
+					node.args["row","rowTarget"];
+				} else if(["addRow2Row"].includes(action)){
+					show=["source"]; 
+					node.args["row","rowTarget","factor","start","end"];
+				} else if(["divideRow"].includes(action)){
+					show=["source"]; 
+					node.args["row","factor","start","end"];
+				} else if(["toArray"].includes(action)){
+					node.args["precision"];
+				};
+				node.args.forEach(property=>$(".form-row-http-in-"+property).show());
+				show.forEach(property=>$(".form-row-http-in-"+property).show());
+			});
+		},
+		oneditsave: function() {
+		},
+		oneditresize: function() {
+		},
+		resizeRule: function(file,newWidth) {
+		}
+	});
+</script>
+
+<script type="text/x-red" data-template-name="matrix">
+
+	<div class="form-row">
+		<label for="node-input-name"><i class="fa fa-tag"></i> Name </label>
+		<input type="text" id="node-input-name" placeholder="Name">
+	</div>
+	<div class="form-row">
+		<label for="node-input-action" style="white-space: nowrap"><i class="icon-list"></i> Action</label>
+		<input type="text" id="node-input-action">
+    </div>
+	<div class="form-row form-row-http-in-source1Propertyx hide">
+		<label for="node-input-source1Propertyx" style="white-space: nowrap"><i class="icon-bookmark"></i> Sourcex`</label>
+		<input type="text" id="node-input-source1Propertyx">
+		<input type="hidden" id="node-input-source1Propertyx-type">
+	</div>
+	<div id="node-inputDynamicBase"/>
+</script>
+
+<script type="text/x-red" data-help-name="matrix">
+	<p>
+	Matrix manipulation
+	</p>
+	<h3>Inputs</h3>
+	<dl class="message-properties">
+		<dt>msg <span class="property-type">topic</span></dt>
+		<dd>incoming message with topic</dd>
+		<dt>msg <span class="property-type">payload</span></dt>
+		<dd></dd>
+	</dl>
+</script>

package/matrix/matrixNode.js

@@ -0,0 +1,145 @@
+const logger = new (require("node-red-contrib-logger"))("matrix");
+logger.sendInfo("Copyright 2022 Jaroslav Peter Prib");
+const Matrix = require("./matrix");
+function error(node,message,shortMessage){
+	if(logger.active) logger.send({label:"error",node:node.id,error:error,shortMessage});
+	node.error(message);
+	node.status({fill:"red",shape:"ring",text:shortMessage});
+}
+function evalFunction(id,mapping){
+	logger.sendInfo({label:"evalFunction",id:id,mapping:mapping})
+	try{
+		return eval(mapping);
+	} catch(ex) {
+		logger.sendError({label:"evalFunction error",id:id,mapping:mapping,error:ex.message})
+		throw Error(id+" "+ex.message);
+	}
+}
+function evalInFunction(node,propertyName){
+	try{
+	    const nodeContext = node.context();
+		const flow = nodeContext.flow;
+		const global = nodeContext.global;
+		const property=node[propertyName];
+		if(property==null) throw Error("no value for "+propertyName);
+		const propertyType=propertyName+"-type";
+		switch (node[propertyType]){
+		case "num":
+			return evalFunction(propertyName,"()=>"+property);
+		case "node":
+			return evalFunction(propertyName,"()=>nodeContext.get("+property+")");
+		case "flow":
+			if(flow) throw Error("context store may be memoryonly so flow doesn't work")
+			return evalFunction(propertyName,"()=>flow.get("+property+")");
+		case "global":
+			return evalFunction(propertyName,"()=>global.get("+property+")");
+		case "env":
+			return evalFunction(propertyName,"()=>env.get("+property+")");
+		case "msg":
+			return evalFunction(propertyName,"(msg)=>msg."+property);
+		default:
+			logger.sendInfo({label:"setData unknown type",action:node.action,propertyType:propertyType,type:node[propertyType]});
+			throw Error("unknown type "+node[propertyType])
+		}
+	} catch(ex) {
+		logger.sendError({label:"setup",error:ex.message,stack:ex.stack});
+		throw Error(property+" "+ex.message);
+	}
+}
+module.exports = function (RED) {
+	function matrixNode(n) {
+	    RED.nodes.createNode(this,n);
+//		logger.sendInfo({label:"create",node:n});
+	    const node=Object.assign(this,n);
+		try{
+			if(node.source)node.getSource=evalInFunction(node,"source");
+			if(node.target) {
+				const nodeContext = node.context();
+				const flow = nodeContext.flow;
+				const global = nodeContext.global;
+				switch(node["target-type"]){
+				case "node":
+					node.setData=evalFunction("target","data=>nodeContext.set("+node.target+",data)");
+					break;
+				case "flow":
+					if(flow) throw Error("context store may be memoryonly so flow doesn't work")
+					node.setData=evalFunction("target","data=>flow.set("+node.target+",data)");
+					break;
+				case "global":
+					node.setData=evalFunction("target","data=>global.set("+node.target+",data)");
+					break;
+				case "msg":
+					node.setData=evalFunction("target","(data,msg)=>{msg."+node.target+"=data;}");
+					break;
+				default:
+					logger.sendInfo({label:"setData unknown type",action:node.action,targetType:node["target-type"]});
+				}
+			}	
+			node.argFunction=[];
+			node.args.forEach(property=>{
+				node.argFunction.push(evalInFunction(node,property).bind(this));
+			})
+			function baseProcess(msg){
+				const sourceIn=node.getSource(msg);
+				if(sourceIn==null) throw Error("source data not found");
+				const sourceMatrix=(sourceIn instanceof Matrix?sourceIn:new Matrix(sourceIn));
+				const args=[];
+				node.argFunction.forEach(callFunction=> {
+					const result=callFunction(msg);
+					args.push(result);
+				});
+				return sourceMatrix[node.action].apply(sourceMatrix,args);
+			}
+			function baseProcessAndSet(msg){
+				const result=baseProcess(msg);
+				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));
+				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.row,columns:node.column});
+				node.setData.apply(node,[sourceMatrix,msg]);
+			}
+			function defineEmptyProcess(msg){
+				if(logger.active) logger.sendInfo({label:"define",arg:{rowsMax:node.row,columns:node.column}});
+				const sourceMatrix=new Matrix({rowsMax:node.row,columns:node.column});
+				node.setData.apply(node,[sourceMatrix,msg]);
+			}
+			node.msgProcess=baseProcess;
+			if(["define"].includes(node.action)){
+				node.msgProcess=defineProcess;
+			}else if(["defineEmpty"].includes(node.action)){
+				node.msgProcess=defineEmptyProcess;
+			}else if(["create"].includes(node.action)){
+					node.msgProcess=createProcess;
+			}else{
+				if(node.action.startsWith("get") 
+				|| ["create","createLike","clone","transpose","sumRow","createForEachCellPairSet",
+					,"findRowColumn","findColumnRow","maxAbsColumn","maxColumn","toArray"
+				].includes(node.action)) {
+					node.msgProcess=baseProcessAndSet;
+				}
+			}
+		} catch(ex) {
+			error(node,ex,"Invalid setup "+ex.message);
+			return;
+		}
+		node.status({fill:"green",shape:"ring"});
+		node.on("input",function (msg) {
+			try{
+				node.msgProcess(msg);
+				node.send(msg);
+			} catch(ex) {
+				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});
+			}
+		});
+	}
+	RED.nodes.registerType(logger.label, matrixNode);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-red-contrib-prib-functions",
-	"version": "0.17.0",
+	"version": "0.18.0",
 	"description": "Node-RED added node functions.",
 	"dependencies": {
 		"avsc": "^5.6.1",
@@ -18,7 +18,7 @@
 		"node-red-node-test-helper": "^0.2.7"
 	},
 	"scripts": {
-		"test": "mocha \"test/**/e*.js\""
+		"test": "mocha \"test/matrix/**/*.js\""
 	},
 	"repository": {
 		"type": "git",
@@ -26,32 +26,44 @@
 	},
 	"keywords": [
 		"node-red",
+		"adjoint",
 		"append",
 		"analysis",
 		"average",
 		"avg",
 		"AVRO",
 		"arvo",
+		"backward substitution",
 		"compare",
+		"Complement Minor",
 		"CMA",
 		"cumulative",
 		"Cumulative Moving Average",
 		"data",
 		"data analysis",
 		"delta",
+		"determinant",
 		"distance",
 		"euclidian distance",
 		"EMA",
 		"EWMA",
 		"Exponential Moving Average",
+		"forward elimination",
 		"functions",
-		"injector",
+		"gauss jordan",
+		"Gauss Jordan Inverse",
+		"gaussian elimination",
 		"host available",
 		"host status",
+		"identity",
+		"injector",
+		"inverse",
+		"inverse matrix",
 		"Linear Correlation Coefficient",
 		"levenshtein distance",
 		"load",
 		"load injector",
+		"matrix",
 		"maximum",
 		"mean",
 		"median",
@@ -66,6 +78,8 @@
 		"Process",
 		"range",
 		"realtime",
+		"Reduced Row Echelon Form",
+		"Row Echelon Form",
 		"sample variance",
 		"sample stddev",
 		"Simple Moving Average",
@@ -82,6 +96,7 @@
 		"test",
 		"translate",
 		"transform",
+		"transpose",
 		"variance",
 		"weighted",
 		"Weighted Moving Average",
@@ -100,6 +115,7 @@
 			"hostAvailable": "testing/hostAvailable.js",
 			"levenshteinDistance": "levenshteinDistance/levenshteinDistanceNode.js",
 			"load-injector": "testing/load-injector.js",
+			"matrix": "matrix/matrixNode.js",
 			"monitorflow": "monitor/monitorflow.js",
 			"os": "nodejs/os.js",
 			"spawnProcess": "spawnProcess/spawnProcess.js",

package/test/dataAnalysis.js

@@ -71,7 +71,7 @@ function test(label,action,data,expected) {
 	}).timeout(4000);
 }
 
-describe('Data Anaysis', function() {
+describe('Data Anaylsis', function() {
 	beforeEach(function(done) {
 		helper.startServer(done);
 	});