@sc-voice/tools 3.23.0 → 3.26.0

package/index.mjs

@@ -3,10 +3,12 @@ export const JS = {
   Assert,
 }
 
+import { Activation } from './src/math/activation.mjs';
 import { Fraction } from './src/math/fraction.mjs';
 import { Interval } from './src/math/interval.mjs';
 
 export const ScvMath = {
+  Activation,
   Fraction,
   Interval,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sc-voice/tools",
-  "version": "3.23.0",
+  "version": "3.26.0",
   "description": "Utilities for SC-Voice",
   "main": "index.mjs",
   "files": [

package/src/defines.mjs

@@ -3,6 +3,7 @@ export const DBG = {
   ALIGN_LINE: 0,
   L2T_TO_STRING: 0,
   COLOR_CONSOLE: 0,
+  C10E_INSPECT: 0,
   I6L_CONTAINS: 0,
   I6L_OVERLAPS: 0,
   ML_DOC_VECTORS: 0, // 'mn8:3.4',

package/src/math/activation.mjs

@@ -0,0 +1,62 @@
+export class Activation {
+  constructor(opts = {}) {
+    const msg = 'A8n.ctor';
+    let { a, b, c, d, fEval, dEval} = opts;
+    if (fEval == null) {
+      throw new Error(`${msg} fEval?`);
+    }
+    this.fEval = fEval;
+    if (dEval == null) {
+      throw new Error(`${msg} dEval?`);
+    }
+    this.dEval = dEval;
+    
+    if (a != null) { this.a = a; }
+    if (b != null) { this.b = b; }
+    if (c != null) { this.c = c; }
+    if (d != null) { this.d = d; }
+  }
+
+  f(x) {
+    let { fEval, a, b, c, d } = this;
+    return fEval(x, a, b, c, d);
+  }
+
+  df(x) {
+    let { dEval, a, b, c, d } = this;
+    return dEval(x, a, b, c, d);
+  }
+
+  // https://en.wikipedia.org/wiki/Soboleva_modified_hyperbolic_tangent
+  static createSoboleva(a = 1, b = 1, c = 1, d = 1) {
+    const msg = 'a8n.createSoboleva';
+    let fEval = (x, a, b, c, d) => {
+      return (Math.exp(a * x) - Math.exp(-b * x)) /
+        (Math.exp(c * x) + Math.exp(-d * x))
+    }
+    let dEval = (x, a, b, c, d) => {
+      console.log(msg, "UNTESTED");
+      return (a*Math.exp(a * x) + b*Math.exp(-b * x)) /
+        (Math.exp(c * x) + Math.exp(-d * x)) -
+        fEval(x,a,b,c,d) * 
+        (c*Math.exp(c * x) - d*Math.exp(-d * x)) /
+        (Math.exp(c * x) + Math.exp(-d * x));
+    }
+      
+    return new Activation({ a, b, c, d, fEval, dEval });
+  }
+
+  static createRareN(a=100,b=1) {
+    let fEval = (x,a) => (x < 1 ? 1 : 1 - Math.exp(((x - a)/x) * b));
+    let dEval = (x,a) => 
+      (x < 1 ? 0 : - ( a * b * fEval(x,a,b)) / (x*x));
+    return new Activation({ a, b, fEval, dEval});
+  }
+
+  static createElu(a=0) {
+    let fEval = (x) => (x >= 0 ? x : (a * (Math.exp(x) - 1)));
+    let dEval = (x) => "TBD";
+    //let dEval = (x) => (x >= 0 ? 1 : fEval(x,a)+a);
+    return new Activation({ a, fEval, dEval });
+  }
+}

package/src/text/color-console.mjs

@@ -1,3 +1,4 @@
+import util from 'node:util';
 import { Unicode } from './unicode.mjs';
 
 const {
@@ -62,6 +63,80 @@ export class ColorConsole {
     return CC;
   }
 
+  static utilColor(ansiColor) {
+    switch (ansiColor) {
+      case BLACK:
+        return 'black';
+      case WHITE:
+        return 'white';
+      case RED:
+        return 'red';
+      case GREEN:
+        return 'green';
+      case BLUE:
+        return 'blue';
+      case CYAN:
+        return 'cyan';
+      case MAGENTA:
+        return 'magenta';
+      case YELLOW:
+        return 'yellow';
+      case BRIGHT_BLACK:
+        return 'blackBright';
+      case BRIGHT_WHITE:
+        return 'whiteBright';
+      case BRIGHT_RED:
+        return 'redBright';
+      case BRIGHT_GREEN:
+        return 'greenBright';
+      case BRIGHT_BLUE:
+        return 'blueBright';
+      case BRIGHT_CYAN:
+        return 'cyanBright';
+      case BRIGHT_MAGENTA:
+        return 'magentaBright';
+      case BRIGHT_YELLOW:
+        return 'yellowBright';
+      case NO_COLOR:
+        return 'noColor';
+    }
+  }
+
+  writeColor(color, rest) {
+    let { styles, defaultOptions } = util?.inspect || {};
+    if (styles) {
+      let oldStyles = Object.assign({}, styles);
+      let oldColors = defaultOptions.colors;
+      defaultOptions.colors = true;
+      let valueColor = ColorConsole.utilColor(this.valueColor);
+      let textColor = ColorConsole.utilColor(color);
+      styles.bigint = valueColor;
+      styles.boolean = valueColor;
+      styles.date = valueColor;
+      //styles.name = textColor;
+      styles.module = 'underline';
+      styles.null = valueColor;
+      styles.number = valueColor;
+      styles.regexp = valueColor;
+      styles.special = valueColor;
+      styles.string = valueColor;
+      //styles.undefined = valueColor;
+
+      this.write(...this.color(color, ...rest));
+
+      Object.assign(util.inspect.styles, oldStyles);
+      defaultOptions.colors = oldColors;
+    } else {
+      this.write(...this.color(color, ...rest));
+    }
+  }
+
+  isOk(thing, tf) {
+    let v = this.valueOf(thing);
+    let color = tf ? this.okColor2 : this.badColor2;
+    return color + v;
+  }
+
   valueOf(thing) {
     const msg = 'c10e.valueOf';
     let { precision } = this;
@@ -99,6 +174,7 @@ export class ColorConsole {
 
   color(textColor, ...things) {
     let { valueColor } = this;
+    let { styleText } = util;
     let label = '';
     let endColor = NO_COLOR;
     let eol;
@@ -106,16 +182,21 @@ export class ColorConsole {
       let newLabel = '';
       let v = this.valueOf(thing);
       let aLast = a.at(-1);
-      if (typeof aLast === 'string' && aLast.endsWith('\n' +  endColor)) {
+      if (
+        typeof aLast === 'string' &&
+        aLast.endsWith('\n' + endColor)
+      ) {
         if (aLast === textColor + '\n' + endColor) {
           a.pop();
         } else {
           const iLast = aLast.lastIndexOf('\n');
           a.pop();
-          a.push(aLast.substring(0, iLast) + aLast.substring(iLast + 1));
+          a.push(
+            aLast.substring(0, iLast) + aLast.substring(iLast + 1),
+          );
         }
         v = '\n' + v;
-      } 
+      }
       switch (typeof thing) {
         case 'object': {
           if (
@@ -154,11 +235,11 @@ export class ColorConsole {
   }
 
   fyi1(...rest) {
-    this.write(...this.color(this.fyiColor1, ...rest));
+    this.writeColor(this.fyiColor1, rest);
   }
 
   fyi2(...rest) {
-    this.write(...this.color(this.fyiColor2, ...rest));
+    this.writeColor(this.fyiColor2, rest);
   }
 
   ok(...rest) {
@@ -166,11 +247,11 @@ export class ColorConsole {
   }
 
   ok1(...rest) {
-    this.write(...this.color(this.okColor1, ...rest));
+    this.writeColor(this.okColor1, rest);
   }
 
   ok2(...rest) {
-    this.write(...this.color(this.okColor2, ...rest));
+    this.writeColor(this.okColor2, rest);
   }
 
   bad(...rest) {
@@ -178,11 +259,11 @@ export class ColorConsole {
   }
 
   bad1(...rest) {
-    this.write(...this.color(this.badColor1, ...rest));
+    this.writeColor(this.badColor1, rest);
   }
 
   bad2(...rest) {
-    this.write(...this.color(this.badColor2, ...rest));
+    this.writeColor(this.badColor2, rest);
   }
 
   tag(...rest) {
@@ -190,10 +271,10 @@ export class ColorConsole {
   }
 
   tag1(...rest) {
-    this.write(...this.color(this.tagColor1, ...rest));
+    this.writeColor(this.tagColor1, rest);
   }
 
   tag2(...rest) {
-    this.write(...this.color(this.tagColor2, ...rest));
+    this.writeColor(this.tagColor2, rest);
   }
 }

package/src/text/list.mjs

@@ -1,12 +1,12 @@
 import { ColorConsole } from './color-console.mjs';
 const { cc } = ColorConsole;
 
-var LIST_FACTORY_SINGLETON;
+let LIST_FACTORY_SINGLETON;
 
 /* Array decorator
  */
 export class ListFactory {
-  constructor(opts={}) {
+  constructor(opts = {}) {
     let {
       nColumns = 0,
       nRows = 0,
@@ -29,15 +29,15 @@ export class ListFactory {
 
   static get SINGLETON() {
     if (LIST_FACTORY_SINGLETON == null) {
-      LIST_FACTORY_SINGLETON = new ListFactory;
+      LIST_FACTORY_SINGLETON = new ListFactory();
     }
     return LIST_FACTORY_SINGLETON;
   }
 
   createList(opts = {}) {
-    let { 
+    let {
       name, // title
-      values=[], 
+      values = [],
       separator = ',', // join() separator
       widths, // element string widths
       precision = this.precision, // numeric precision
@@ -70,7 +70,7 @@ export class ListFactory {
       value: () => {
         let strs = list.toStrings();
         return strs.join(list.separator);
-      }
+      },
     });
     Object.defineProperty(list, 'toStrings', {
       value: () => {
@@ -95,36 +95,35 @@ export class ListFactory {
                 s = JSON.stringify(v);
               }
               break;
-            case 'number': {
-              let sRaw = precision ? v.toFixed(precision) : v+'';
-              let sShort = sRaw.replace(/\.?0+$/, '');
-              s = Number(sShort) === v ? sShort : sRaw;
-            }
-            break;
+            case 'number':
+              {
+                let sRaw = precision ? v.toFixed(precision) : v + '';
+                let sShort = sRaw.replace(/\.?0+$/, '');
+                s = Number(sShort) === v ? sShort : sRaw;
+              }
+              break;
             default:
-              s +=  v;
+              s += v;
               break;
           }
           let width = widths?.[i];
           if (width) {
-            s = s.substring(0,width).padEnd(width);
+            s = s.substring(0, width).padEnd(width);
           }
           s5s.push(s);
         }
 
-
         return s5s;
-      }
-
+      },
     });
 
     return list;
   }
 
   createColumn(opts = {}) {
-    let { 
-      name, 
-      values=[], 
+    let {
+      name,
+      values = [],
       separator = '\n',
       precision = this.precision,
     } = opts;
@@ -134,17 +133,17 @@ export class ListFactory {
       name = 'column' + this.nColumns;
     }
     return this.createList({
-      name, 
+      name,
       precision,
-      separator, 
-      values, 
+      separator,
+      values,
     });
   }
 
   createRow(opts = {}) {
-    let { 
-      name, 
-      values=[], 
+    let {
+      name,
+      values = [],
       separator = '\t',
       widths,
       precision = this.precision,
@@ -155,10 +154,10 @@ export class ListFactory {
       name = 'row' + this.nRows;
     }
     return this.createList({
-      name, 
+      name,
       precision,
-      separator, 
-      values, 
+      separator,
+      values,
       widths,
     });
   }
@@ -176,12 +175,13 @@ export class ListFactory {
       precision = this.precision,
     } = opts;
 
-    let singleList = this.createColumn({ 
-      name, 
-      separator:rowSeparator,
+    let singleList = this.createColumn({
+      name,
+      separator: rowSeparator,
       precision,
     });
-    let newRow = (separator) => this.createRow({ separator, precision });
+    let newRow = (separator) =>
+      this.createRow({ separator, precision });
     name = name || singleList.name;
     switch (order) {
       case 'col-major':
@@ -251,20 +251,23 @@ export class ListFactory {
 
     // compute row element widths
     let widths = new Array(maxValues).fill(0);
-    singleList.forEach(row => {
+    singleList.forEach((row) => {
       let strs = row.toStrings();
-      strs.map((s,i)=> {
+      strs.map((s, i) => {
         widths[i] = Math.max(s.length, widths[i]);
       });
     });
-    singleList.forEach(row => row.widths = widths);
-    dbg && cc.ok1(msg+1, widths[0], maxValues, 'widths:', widths);
+    singleList.forEach((row) => {
+      row.widths = widths;
+    });
+    dbg && cc.ok1(msg + 1, widths[0], maxValues, 'widths:', widths);
 
     return singleList;
   }
 }
 
-export class List { // namespace wrapper for ListFactory
+export class List {
+  // namespace wrapper for ListFactory
   static createColumn(opts = {}) {
     return ListFactory.SINGLETON.createColumn(opts);
   }
@@ -274,6 +277,6 @@ export class List { // namespace wrapper for ListFactory
   }
 
   static wrapList(list, opts = {}) {
-    return ListFactory.SINGLETON.wrapList(list, opts); 
+    return ListFactory.SINGLETON.wrapList(list, opts);
   }
 }

package/src/text/unicode.mjs

@@ -281,7 +281,28 @@ export class Unicode {
       BRIGHT_MAGENTA: '\u001b[95m',
       BRIGHT_CYAN: '\u001b[96m',
       BRIGHT_WHITE: '\u001b[97m',
-      NO_COLOR: '\u001b[0m',
+      NO_COLOR: '\u001b[39m',
+    };
+  }
+
+  static get LINUX_STYLE() {
+    return {
+      BOLD: '\u001b[1m',
+      DIM: '\u001b[2m',
+      NO_BOLD: '\u001b[22m',
+      ITALIC: '\u001b[3m',
+      NO_ITALIC: '\u001b[23m',
+      UNDERLINE: '\u001b[4m',
+      NO_UNDERLINE: '\u001b[24m',
+      BLINK: '\u001b[5m',
+      NO_BLINK: '\u001b[25m',
+      INVERSE: '\u001b[7m',
+      NO_INVERSE: '\u001b[27m',
+      HIDE: '\u001b[8m',
+      NO_HIDE: '\u001b[28m',
+      STRIKETHROUGH: '\u001b[9m',
+      NO_STRIKETHROUGH: '\u001b[29m',
+      RESET: '\u001b[0m',
     };
   }