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

package/README.md

@@ -2,17 +2,17 @@
 
 [Node-Red][1] nodes for various functions:
 
-*   Data Analysis  - statistical metrics that has real time option
-*   Matrix
-*   Transform
-*   Test
-*   Load Injector
-*   Monitor Flow
-*   append
-*   Spawn Process
-*   Host Available
-*   node.js os metrics
-*   Levenshtein Distance
+* Data Analysis  - statistical metrics that has real time option
+* Matrix
+* Transform
+* Test
+* Load Injector
+* Monitor Flow
+* append
+* Spawn Process
+* Host Available
+* node.js os metrics
+* Levenshtein Distance
 
 ------------------------------------------------------------
 
@@ -30,7 +30,8 @@ being outside 3 standard deviations from mean. This can be changed to median and
 A set of data analysis functions that can be run over an array of data
 
 Single value metrics:
-* autocorrelation
+
+* Autocorrelation
 * Autocovariance
 * Average/Mean
 * Maximum
@@ -43,6 +44,7 @@ Single value metrics:
 * Variance
 
 Array metrics:
+
 * Deltas
 * Deltas Normalised
 * difference
@@ -56,11 +58,11 @@ Array metrics:
 * Standardization (Z-score Normalization)
 
 Array data
-* distances 
+
+* distances
 * distance(s) minimum between points
 * distance(s) maximum between points
 
-
 ![Data Analysis](documentation/DataAnalysis.JPG "Data Analysis")
 
 example:
@@ -69,36 +71,33 @@ example:
 
 ![Data Analysis Pearson R example](documentation/DataAnalysisTestPearsonR.JPG "Data Analysis PearsonR example")
 
-
 ![Data Analysis example](documentation/DataAnalysisTest.JPG "Data Analysis example")
 
-
 ------------------------------------------------------------
 
 ## Matrix
 
 Define a matrix and perform various functions
 
- * Define / Define Empty / Create / Create Like/ clone
- * Add / Add Row to Row / Add to Cell / Add Row / Subtract Cell
- * Multiple / Multiple Cell / Divide Cell / Divide Row
- * Transpose
- * Adjoint
- * Cofactor
- * Complement Minor
- * Identity
- * Inverse
- * Determinant
- * Backward Substitution
- * Forward Elimination
- * Gaussian Elimination
- * Reduced Row EchelonForm
- * Row Echelon Form
- * Nearly Equals / Is Square / Get Cell
- * Sum Row
- * Swap Rows
- * To Array Object
-
+* Define / Define Empty / Create / Create Like/ clone
+* Add / Add Row to Row / Add to Cell / Add Row / Subtract Cell
+* Multiple / Multiple Cell / Divide Cell / Divide Row
+* Transpose
+* Adjoint
+* Cofactor
+* Complement Minor
+* Identity
+* Inverse
+* Determinant
+* Backward Substitution
+* Forward Elimination
+* Gaussian Elimination
+* Reduced Row EchelonForm
+* Row Echelon Form
+* Nearly Equals / Is Square / Get Cell
+* Sum Row
+* Swap Rows
+* To Array Object
 
 ![Matrix](documentation/matrix.jpg "Matrix")
 
@@ -107,68 +106,118 @@ Define a matrix and perform various functions
 ## Transform
 
 Translates a selected msg property to a target property.
-Messages generates a message for each row or record. 
+Messages generates a message for each row or record.
 
 Transformations:
 
-*   Array to CSV
-*   Array to HTML
-*   Array to ISO8385
-*   Array to Messages
-*   Array to xlsx / xlsx object (excel uses [xlsx][7])  
-*   AVRO to JSON (uses [avsc][6])
-*   Buffer to comprossed 
-*   Confluence to JSON
-*   Compressed to Buffer
-*   Compressed to String
-*   COmpressed to JSON
-*   CSV to Array
-*   CSV to HTML
-*   CSV to Messages
-*   CSVWithHeader to Array
-*   CSVWithHeader to HTML
-*   CSVWithHeader to JSON
-*   ISO8385 to Array
-*   ISO8385 to JSON
-*   JSON to Array
-*   JSON to Confluence
-*   JSON to CSV
-*   JSON to AVRO (uses [avsc][6])
-*   JSON to ISO8385
-*   JSON to Messages
-*   JSON to String
-*   JSON to xlsx / xlsx object (excel uses [xlsx][7])  
-*   JSON to XML (uses [fast-xml-parser][4])
-*   String to JSON
-*   path to Basename
-*   path to Dirname
-*   path to Extname
-*   path to Format
-*   path to Is Absolute
-*   path to Join
-*   path to Parse
-*   path to Normalize
-*   path to Resolve
-*   snappy compress (uses [snappy][5], must install separately)
-*   snappy uncompress (uses [snappy][5], must install separately)
-*   xlsx / xlsx object to array/JSON (excel uses [xlsx][7])  
-*   XML to JSON (uses [fast-xml-parser][4])
+* Array to
+  * CSV
+  * HTML
+  * ISO8385
+  * Messages
+  * xlsx / xlsx object (excel uses [xlsx][7])  
+* AVRO to JSON (uses [avsc][6])
+* Buffer to compressed
+* Confluence to JSON
+* Compressed to
+  * Buffer
+  * String
+  * JSON
+* CSV to
+  * Array
+  * HTML
+  * Messages
+* CSVWithHeader to
+  * Array
+  * HTML
+  * JSON
+* Date to
+  * is between
+  * ISO string
+  * locale string
+  * range limit
+* ISO8385 to Array
+* ISO8385 to JSON
+* JSON to
+  * Array
+  * Confluence
+  * CSV
+  * AVRO (uses [avsc][6])
+  * ISO8385
+  * Messages
+  * String
+  * xlsx / xlsx object (excel uses [xlsx][7])  
+  * XML (uses [fast-xml-parser][4])
+* Number
+  * is between
+  * range limit
+* path
+  * Basename
+  * Dirname
+  * Extname
+  * Format
+  * Is Absolute
+  * Join
+  * Parse
+  * Normalize
+  * Resolve
+* snappy compress (uses [snappy][5], must install separately)
+* snappy uncompress (uses [snappy][5], must install separately)
+* String to
+  * Append
+  * Array By Delimiter
+  * At
+  * Camelize
+  * Capitalize
+  * Compressed
+  * Char At
+  * Char Code At"
+  * Code Point At
+  * Concat
+  * Date
+  * Delimiter On Case
+  * _ to space
+  * _ to space Capitilize
+  * Drop square bracket prefix
+  * Ends With
+  * Float
+  * Get Word
+  * Integer
+  * is Between
+  * Lower Case
+  * Number
+  * Prepend
+  * JSON
+  * Range Limit
+  * Split
+  * Starts With
+  * Timestamp
+  * Title
+  * Title Grammatical
+  * Trim
+  * Trim End
+  * Trim Start
+  * Upper Case
+  * Xml String Encode
+
+* xlsx / xlsx object to array/JSON (excel uses [xlsx][7])  
+* XML to JSON (uses [fast-xml-parser][4])
 
 Note, snappy needs to be installed separately as can have issues with auto install as build binaries.
 
 With xlsx object one can use the function in [xlsx][7] against the object in functions node.
-
+"
 Example AVRO with schema
 
 ![Transform AVRO](documentation/transformArvo.jpg "Transform AVRO example")
 
-For Confluence schema contains a list of schemas in form {"<schema id>",<schema>}
+For Confluence schema contains a list of schemas in form {"\<schema id\>",\<schema\>}
 
 ------------------------------------------------------------
 
 ## Test
 
-Allows a test case for a message to allow simple testing of nodes. Injects a new message via mouse or message. Message sent to first port which can be consumed by other nodes and returned back to node in a loop. The Test node then checks against detailed expected payload result. 
+Allows a test case for a message to allow simple testing of nodes. Injects a new message via mouse or message. Message sent to first port which can be consumed by other nodes and returned back to node in a loop. The Test node then checks against detailed expected payload result.
 
 ![Test](documentation/Test.JPG "Test")
 
@@ -209,11 +258,11 @@ Inject messages for a set period of time with varying think time.
 Primary purpose is testing and useful for load/stress testing.
 
 Has 3 extra data types
+
 1. generated id - Unique id for each message
 2. generated data - string text generated using [dummy-json][3]
 3. generated json - json generated using [dummy-json][3]
 
-
 ![Load Injector](documentation/loadInjector.png "Load Injector")
 
 Test example:
@@ -249,7 +298,7 @@ Test example:
 
 ------------------------------------------------------------
 
-## Monitor System 
+## Monitor System
 
 System monitoring metrics
 
@@ -279,7 +328,7 @@ Spawn process as per node.js manual with ability to set working directory, envir
 and argument passed to process. STDOUT and STDERR are sent as individual messages.
 RC port is sent a message on closure.
 Takes in messages that starts a process with ability to add environment values.
-Message can be sent to kill the process.    
+Message can be sent to kill the process.
 
 ![Spawn Process](documentation/SpawnProcess.JPG "Spawn Process")
 
@@ -289,19 +338,23 @@ Test example:
 
 ------------------------------------------------------------
 
-# Install
+## Install
 
 Run the following command in the root directory of your Node-RED install
 
     npm install node-red-contrib-prib-functions
 
-# Tests
+## Tests
 
 Test/example flow in test/generalTest.json
 
 ------------------------------------------------------------
 
-# Version
+## Version
+
+0.23.3 Removes bug in test, more translation
+
+0.23.0 Removes bug in test, more translation
 
 0.22.0 Add autocovariance + autocorealationship to real time data analystics, improves test
 
@@ -315,8 +368,7 @@ Test/example flow in test/generalTest.json
 
 0.17.0 Add finished wire to load injector
 
-
-# Author
+## Author
 
 [Peter Prib][3]
 
@@ -333,5 +385,3 @@ Test/example flow in test/generalTest.json
 [6]: https://www.npmjs.com/package/avsc "avsc"
 
 [7]: https://www.npmjs.com/package/xlsx "xlsx"
-
-[8]: https://www.npmjs.com/package/dummy-json "dummy-json"

package/lib/AlphaBeta.js

@@ -0,0 +1,32 @@
+function alphabeta(node, depth, 
+    isTerminalNode=node=>node.children.lenght==0 ,
+    forEachChild=call=>this.children.forEach(c=>call(c)),
+    getHeuristicValue=node=>node.value,
+    alpha=-Infinity, beta=Infinity,
+    maximizingPlayer=true
+){
+    if( depth == 0 || isTerminalNode(node)) return getHeuristicValue (node)
+    const notMaximizingPlayer=!maximizingPlayer
+    const minMaxFunction=maximizingPlayer?Math.max:Math.min
+    let value=Infinity*(maximizingPlayer?-1:1)
+    let loopFunction=maximizingPlayer?
+        child=>{ 
+            value = minMaxFunction(value,
+                minimax(child,depth-1,isTerminalNode,forEachChild,getHeuristicValue ,alpha, beta, notMaximizingPlayer))
+            if(value >= beta ) throw Error("break")
+            else alpha = minMaxFunction(alpha, value)
+        }:child=>{
+            value = minMaxFunction(value,
+                minimax(child,depth-1,isTerminalNode,forEachChild,getHeuristicValue ,alpha, beta, notMaximizingPlayer))
+            if(value <= alpha) throw Error("break") 
+            beta = minMaxFunction(beta, value)
+        }
+    try{
+        forEachChild(loopFunction)
+    } catch(ex){
+        if(ex.message!=="break") throw ex
+    }
+    return value
+}
+
+module.exports=alphabeta

package/lib/GraphDB.js

@@ -1,14 +1,45 @@
 require("../lib/objectExtensions")
+function Edge(from,to,properties){
+  if(!from) throw Error("from vertix is not defined")
+  if(!to) throw Error("to vertix is not defined")
+  if(!from instanceof Vertex) throw Error("from not type Vertex")
+  if(!to instanceof Vertex) throw Error("to not type Vertex")
+  Object.assign(this,{_from:from,_to:to},properties)
+  from.addTo(this)
+  to.addFrom(this)
+}
+function Vertex(properties){
+  Object.assign(this,{_to:[],_from:[]},properties)
+}
+Vertex.prototype.addTo=function(r){
+  this._to.push(r)  
+}
+Vertex.prototype.addFrom=function(r){
+  this._from.push(r)  
+}
 function GraphDB(properties){
-    Object.assign(this,{type:null,vertices:[],edges:[]},properties)
-
+  Object.assign(this,{vertices:[],edges:[]},properties)
+}
+GraphDB.prototype.addEdge=function(from,to,properties) {
+  const edge=new Edge(from,to,properties)
+  this.edges.push(edge)
+  return edge
+}
+GraphDB.prototype.addVertex=function(vertexDetails) {
+  const vertex=new Vertex(vertexDetails)
+  this.vertices.push(vertex)
+  return vertex
+}
+GraphDB.prototype.getEdgesCount=function() {
+  return this.edges.length
+}
+GraphDB.prototype.getVerticesCount=function() {
+  return this.vertices.length
 }
-GraphDB.prototype.addVertex=function(vertex) {
-    this.vertices.addList(vertex)
+GraphDB.prototype.getVertices=function(filterFunction) {
+  return this.vertices.filter(filterFunction)
 }
-GraphDB.prototype.addEdge=function(from,to) {
-    this.edges.addList({from:from,to:to})
+GraphDB.prototype.getEdges=function(filterFunction) {
+  return this.Edges.filter(filterFunction)
 }
-
-this.addErrorFunctions()
-module.exports=GraphDB  
+module.exports=GraphDB

package/lib/MinMax.js

@@ -0,0 +1,17 @@
+function minimax(node, depth, 
+    isTerminalNode=node=>node.children.lenght==0 ,
+    forEachChild=call=>this.children.forEach(c=>call(c)),
+    getHeuristicValue =node=>node.value,
+    maximizingPlayer=true
+){
+    if( depth == 0 || isTerminalNode(node)) return getHeuristicValue (node)
+    const notMaximizingPlayer=!maximizingPlayer
+    const minMaxFunction=maximizingPlayer?Math.max:Math.min
+    let value=Infinity*(maximizingPlayer?-1:1)
+    forEachChild(child=> value = minMaxFunction(value,
+         minimax(child,depth-1,isTerminalNode,forEachChild,getHeuristicValue ,notMaximizingPlayer))
+    )
+    return value
+}
+
+module.exports=minimax

package/lib/Tree.js

@@ -0,0 +1,64 @@
+function Level(parent,...children){
+    this.children=children
+    this.setBTree(10)
+}
+function Leaf(parent,value){
+    this.values=[]
+}
+Leaf.prototype.find=function(value,foundCall,notFoundCall=foundCall,notFoundAllCall=v=>notFoundCall(0,v)){
+    let i=this.keys.length
+    const key=this.getKey(value)
+    while (i >= 0){
+        const currentKey=this.getKey(this.values[i])
+        if(key>currentKey) return notFoundCall(i,key)
+        if(key==currentKey) return foundCall(i,key)
+        i--
+    }
+    notFoundAllCall(key)
+}
+Leaf.prototype.getKey=function(node){return node}
+Leaf.prototype.insert=function(value){
+    const _this=this
+    this.find(value,i=>_this.values.splice(i, 0, value))
+}
+function Tree (root=new Level(null)){
+  this.root=root
+}
+Tree.prototype.setDegree=function(v){this.degree=v}
+
+
+
+Tree.prototype.insert(key,value) {
+    const root = this.root;
+    if(root.keys.length === (2 * this.degree - 1)) { // Root is full
+        const newRoot = new BTreeNode(false);
+        newRoot.children.push(root);
+            this.splitChild(newRoot, 0, root);
+            this.root = newRoot;
+            this.insertNonFull(newRoot, key);
+        } else {
+            this.insertNonFull(root, key);
+        }
+}
+
+Tree.prototype.insertNonFull(node, key) {
+    let i = node.keys.length - 1;
+    if (node.isLeaf) {
+
+    } else {
+            while (i >= 0 && key < node.keys[i]) {
+                i--;
+            }
+            i++;
+            if (node.children[i].keys.length === (2 * this.degree - 1)) {
+                this.splitChild(node, i, node.children[i]);
+                if (key > node.keys[i]) {
+                    i++;
+                }
+            }
+            this.insertNonFull(node.children[i], key);
+        }
+    }
+
+
+module.exports=Tree

package/lib/common.js

@@ -0,0 +1,128 @@
+const error=(node,message,shortMessage,logger)=>{
+	if(logger && logger.active) logger.send({label:"error",node:node.id,error:error,shortMessage});
+	node.error(message);
+	node.status({fill:"red",shape:"ring",text:shortMessage});
+}
+const evalFunction(id,mapping,logger)=>{
+	logger&&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);
+	}
+}
+const 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";
+		if(! (propertyType in node)) return evalFunction(propertyName,"()=>node."+property) 
+		switch (node[propertyType]){
+		case "num":
+		case "json":
+			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);
+	}
+}
+
+const argsArray=(node,msg)=>{
+	const args=[];
+	node.argFunction.forEach(callFunction=> {
+		const result=callFunction(msg);
+		args.push(result);
+	});
+	return args;
+}
+const setArgsFunction=(node)=>{
+    node.argFunction=[];
+    node.args.forEach(property=>{
+        try{
+            node.argFunction.push(evalInFunction(node,property).bind(this));
+        } catch(ex) {
+            throw Error("args "+property+" "+ex.message)
+        }
+    })
+}
+
+
+const setTargetFunction=(node)=>{
+    if(node.target) throw Error("target is null")
+    if(node.hasOwnProperty("target-type")) {
+        node.setData=evalFunction("target","data=>data)")
+        return
+    }
+    const nodeContext = node.context()
+    const type=node["target-type"]
+    switch(type){
+        case "node":
+        node.setData=evalFunction("target","data=>nodeContext.set("+node.target+",data)")
+            break
+        case "flow":
+            if(nodeContext.flow) throw Error("context store may be memory only so flow doesn't work")
+            node.setData=evalFunction("target","data=>nodeContext.flow.set("+node.target+",data)")
+            break
+        case "global":
+            node.setData=evalFunction("target","data=>nodeContext.global.set("+node.target+",data)")
+            break
+        case "msg":
+            node.setData=evalFunction("target","(data,msg)=>{msg."+node.target+"=data;}")
+            break
+        default:
+            throw Error("setData unknown type "+type)
+    }
+}
+
+const baseProcess=(msg,call=sourceMatrix[node.action])=>{
+    const value=node.getSource(msg);
+    if(value==null) throw Error("source data not found");
+    const valueObject=(value instanceof Matrix?value:new Matrix(value));
+    return call.apply(valueObject,argsArray(node,msg));
+}
+const baseProcessAndSet=(msg)=>{
+    const result=baseProcess(msg);
+    node.setData.apply(node,[result,msg]);
+}
+function createProcess(msg){
+    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){
+    const sourceMatrix=new Matrix({rows:node.rows,columns:node.columns,dataType:node.dataType});
+    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.rows,columns:node.columns});
+    node.setData.apply(node,[sourceMatrix,msg]);
+}
+function createSize(msg){
+    const sourceMatrix=new Matrix({rows:node.size,columns:node.size});
+    node.setData.apply(node,[sourceMatrix[node.action](),msg]);
+}
+function createDummy(msg){
+    const sourceMatrix=new Matrix(1,1);
+    node.setData.apply(node,[sourceMatrix[node.action].apply(sourceMatrix,argsArray(node,msg)),msg]);
+}