@sc-voice/tools 3.13.0 → 3.15.0

package/package.json

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

package/src/defines.mjs

@@ -1,6 +1,8 @@
 export const DBG = {
   ALIGN_ALL: 0,
   ALIGN_LINE: 0,
+  I6L_CONTAINS: 0,
+  I6L_OVERLAPS: 0,
   ML_DOC_VECTORS: 0, // 'mn8:3.4',
   MN8_MOHAN: 0,
   DEEPL_ADAPTER: 0,

package/src/math/interval.mjs

@@ -1,20 +1,29 @@
 import { Unicode } from '../text/unicode.mjs';
-const { INFINITY } = Unicode;
+const { EMPTY_SET, INFINITY } = Unicode;
+import { ColorConsole } from '../text/color-console.mjs';
+const { cc } = ColorConsole;
+import { DBG } from '../defines.mjs';
 
 const MINUS_INFINITY = `-${INFINITY}`;
 const PLUS_INFINITY = `+${INFINITY}`;
 
 export class Interval {
-  constructor(a, b) {
+  constructor(a, b, opts = {}) {
     const msg = 'i6l.ctor';
     let hi = null;
     let lo = null;
     const dbg = 0;
+    let { leftOpen = false, rightOpen = false } = opts;
+    if (a === INFINITY || a == null) {
+      leftOpen = true;
+    }
+    if (b === INFINITY || b == null) {
+      rightOpen = true;
+    }
 
     let an = typeof a === 'number' && !Number.isNaN(a);
     let bn = typeof b === 'number' && !Number.isNaN(b);
 
-    let isClosed = true;
     if (an && bn) {
       if (b < a) {
         throw new Error(`${msg} invalid interval ${b}<${a}?`);
@@ -22,25 +31,18 @@ export class Interval {
       dbg && console.log(msg, 'an bn');
       lo = a;
       hi = b;
-      isClosed = true;
     } else if (an) {
       dbg && console.log(msg, 'an');
       lo = a;
       hi = INFINITY;
-      isClosed = false;
     } else if (bn) {
       dbg && console.log(msg, 'bn');
       lo = INFINITY;
       hi = b;
-      isClosed = false;
     } else {
       dbg && console.log(msg, '!an !bn');
-      isClosed = false;
     }
 
-    Object.defineProperty(this, 'isClosed', {
-      value: isClosed,
-    });
     Object.defineProperty(this, 'lo', {
       enumerable: true,
       value: lo,
@@ -49,12 +51,28 @@ export class Interval {
       enumerable: true,
       value: hi,
     });
+    Object.defineProperty(this, 'leftOpen', {
+      enumerable: true,
+      value: leftOpen,
+    });
+    Object.defineProperty(this, 'rightOpen', {
+      enumerable: true,
+      value: rightOpen,
+    });
   }
 
   static get INFINITY() {
     return INFINITY;
   }
 
+  get isOpen() {
+    return this.leftOpen || this.rightOpen || this.isEmpty;
+  }
+
+  get isClosed() {
+    return (!this.leftOpen && !this.rightOpen) || this.isEmpty;
+  }
+
   get isEmpty() {
     if (this.lo === null && this.hi === null) {
       return true;
@@ -78,16 +96,25 @@ export class Interval {
   }
 
   contains(num) {
+    const msg = 'i6l.contains';
+    const dbg = DBG.I6L_CONTAINS;
     if (typeof num !== 'number' || Number.isNaN(num)) {
+      dbg && cc.fyi1(msg+0.1, false);
       return false;
     }
-    let { lo, hi } = this;
+    let { lo, hi, leftOpen, rightOpen } = this;
     if (lo === INFINITY) {
       throw new Error(`${msg}TBD`);
     }
     if (hi === INFINITY) {
       throw new Error(`${msg}TBD`);
     }
+    if (lo === num && leftOpen) {
+      return false;
+    }
+    if (hi === num && rightOpen) {
+      return false;
+    }
     if (lo < num && num < hi) {
       return true;
     }
@@ -99,35 +126,53 @@ export class Interval {
   }
 
   toString() {
-    let { lo, hi } = this;
+    let { lo, hi, leftOpen, rightOpen, isEmpty } = this;
+    if (isEmpty) {
+      return EMPTY_SET;
+    }
     if (lo === hi) {
       return [
-        lo === INFINITY ? '(' : '[',
+        leftOpen ? '(' : '[',
         lo === INFINITY ? MINUS_INFINITY : lo,
         lo == null ? '' : ',',
         hi === INFINITY ? PLUS_INFINITY : hi,
-        hi === INFINITY ? ')' : ']',
+        rightOpen ? ')' : ']',
       ].join('');
     }
     return [
-      lo === INFINITY ? '(' : '[',
+      leftOpen ? '(' : '[',
       lo === INFINITY ? MINUS_INFINITY : lo,
       lo === hi ? '' : ',',
       hi === INFINITY ? PLUS_INFINITY : hi,
-      hi === INFINITY ? ')' : ']',
+      rightOpen ? ')' : ']',
     ].join('');
   }
 
   overlaps(iv2) {
     const msg = 'i6l.overlaps';
-    let { lo:lo1, hi:hi1 } = this;
-    let { lo:lo2, hi:hi2 } = iv2;
+    const dbg = DBG.I6L_OVERLAPS;
+    let { lo: lo1, hi: hi1, leftOpen:lOpen1, rightOpen: rOpen1 } = this;
+    let { lo: lo2, hi: hi2, leftOpen:lOpen2, rightOpen: rOpen2 } = iv2;
 
     //console.log(msg, {lo1, lo2, hi1, hi2});
-    return (
-      (lo2 <= lo1 && lo1 <= hi2) ||
-      (lo2 <= hi1 && hi1 <= hi2) ||
-      (lo1 <= lo2 && lo2 <= hi1)
-    );
+    if (!lOpen1 && iv2.contains(lo1)) {
+      dbg && cc.fyi1(msg+1, 'lo1');
+      return true;
+    }
+    if (!rOpen1 && iv2.contains(hi1)) {
+      dbg && cc.fyi1(msg+2, 'hi1');
+      return true;
+    }
+    if (!lOpen2 && this.contains(lo2)) {
+      dbg && cc.fyi1(msg+3, 'lo2');
+      return true;
+    }
+    if (!rOpen2 && this.contains(hi2)) {
+      dbg && cc.fyi1(msg+4, 'hi2');
+      return true;
+    }
+
+    dbg && cc.fyi1(msg+0.1, false);
+    return false;
   }
 }

package/src/text/color-console.mjs

@@ -20,6 +20,8 @@ const {
   NO_COLOR,
 } = Unicode.LINUX_COLOR;
 
+let CC;
+
 export class ColorConsole {
   constructor(opts = {}) {
     let {
@@ -35,7 +37,6 @@ export class ColorConsole {
       colorTag4 = BRIGHT_MAGENTA,
       precision = 3,
       write = (...args) => console.log.call(null, ...args),
-
     } = opts;
 
     Object.assign(this, {
@@ -51,42 +52,48 @@ export class ColorConsole {
       colorTag4,
       precision,
       write,
-
     });
   }
 
+  static get cc() {
+    CC = CC || new ColorConsole();
+    return CC;
+  }
+
   color(color, ...things) {
     let { precision } = this;
     let label = '';
-    return things.reduce((a,thing) => {
+    return things.reduce((a, thing) => {
       let newLabel = '';
       switch (typeof thing) {
-        case 'object':
+        case 'object': {
           label && a.push(label);
-          let s = thing && 
-            (thing.constructor !== Object) &&
-            (typeof thing.toString) === 'function'
-            ? color+thing.toString()+NO_COLOR
-            : thing;
+          let s =
+            thing &&
+            thing.constructor !== Object &&
+            typeof thing.toString === 'function'
+              ? color + thing.toString() + NO_COLOR
+              : thing;
           a.push(s);
           break;
+        }
         case 'string':
           if (thing.endsWith(':')) {
-            newLabel = NO_COLOR+thing;
+            newLabel = NO_COLOR + thing;
           } else {
-            a.push(label+color+thing+NO_COLOR);
+            a.push(label + color + thing + NO_COLOR);
           }
           break;
         case 'number': {
           let v = thing.toFixed(precision);
           if (thing === Number(v)) {
-            v = v.replace(/\.?0+$/, '')
+            v = v.replace(/\.?0+$/, '');
           }
-          a.push(label+GREEN+v+NO_COLOR);
+          a.push(label + GREEN + v + NO_COLOR);
           break;
         }
         default:
-          a.push(label+color+JSON.stringify(thing)+NO_COLOR);
+          a.push(label + color + JSON.stringify(thing) + NO_COLOR);
           break;
       }
       label = newLabel;

package/src/text/unicode.mjs

@@ -220,6 +220,9 @@ export class Unicode {
   static get IMPLIES() {
     return '\u21D2';
   }
+  static get EMPTY_SET() {
+    return '\u2205';
+  }
   static get ELEMENT_OF() {
     return '\u2208';
   }
@@ -352,9 +355,12 @@ export class Unicode {
   get ELLIPSIS() {
     return Unicode.ELLIPSIS;
   }
-  get IMPLIES(){
+  get IMPLIES() {
     return Unicode.IMPLIES;
   }
+  get EMPTY_SET() {
+    return Unicode.EMPTY_SET;
+  }
   get ELEMENT_OF() {
     return Unicode.ELEMENT_OF;
   }