Creating chainable calculations with the SafeMath class

Question

Creating chainable calculations with the SafeMath class

I'm struggling to find the right keywords for my online search regarding this matter.

Recently, I developed a class containing safe math functions. Each function requires 2 arguments and returns the result after undergoing an assertion process.

For instance:

class SafeMath {

  static add(x: number, y: number) {
    let z: number = x + y;
    assert(z >= x, 'ds-math-add-overflow');
    return z;
  }

  static sub(x: number, y: number) {
    let z: number = x - y;
    assert(z <= x, 'ds-math-sub-underflow');
    return z;
  }

  static mul(x: number, y: number) {
    let z: number = x * y;
    assert(y == 0 || z / y == x, 'ds-math-mul-overflow');
    return z;
  }

  static div(x: number, y: number) {
    let z: number = x / y;
    assert(x > 0 || y > 0, 'ds-math-div-by-zero');
    return z;
  }

}

console.log(SafeMath.add(2,2)); // 4
console.log(SafeMath.sub(2,2)); // 0
console.log(SafeMath.mul(2,2)); // 4
console.log(SafeMath.div(2,2)); // 1

The aim behind these functions is to allow them to operate as follows:

let balance0: number = 1;
let balance1: number = 1;

let amount0In: number = 10;
let amount1In: number = 10;

let balance0Adjusted: number = balance0.mul(1000).sub(amount0In.mul(3));
let balance1Adjusted: number = balance1.mul(1000).sub(amount1In.mul(3));

In this scenario, the functions will take in y and utilize the preceding number as x.

javascript typescript deno

Answer 1

Answer №1

If you need a solution, consider creating a wrapper function like this:

if (!Number.prototype.multiply)  // checking if the multiply method doesn't already exist 
  {
  Number.prototype.multiply = function(num){ return this * num }
  }
  
if (!Number.prototype.addition)
  {
  Number.prototype.addition = function(num){ return this + num }
  }
  
let value = 10
let result = value.multiply(2).addition(100)

console.log(result)

Answer 2

If you need a solution, consider creating a wrapper function like this:

if (!Number.prototype.multiply)  // checking if the multiply method doesn't already exist 
  {
  Number.prototype.multiply = function(num){ return this * num }
  }
  
if (!Number.prototype.addition)
  {
  Number.prototype.addition = function(num){ return this + num }
  }
  
let value = 10
let result = value.multiply(2).addition(100)

console.log(result)

Answer 3

Answer №2

If you want to customize the functionality of Number.prototype, you can enhance it with additional methods to allow for chaining operations. It is generally advised against extending native objects using string property keys (refer to Why is extending native objects a bad practice?). To avoid potential conflicts and maintain uniqueness, consider using symbol property keys instead of strings.

For instance, here's a sample module that safely extends Number.prototype with a multiplication function utilizing a unique symbol, while also including the new function signature in the TypeScript Number interface:

mul.ts

const mul = Symbol("multiply");

function value(this: number, n: number) {
  return this * n;
}

declare global {
  interface Number {
    [mul]: typeof value;
  }
}

Object.defineProperty(Number.prototype, mul, { value });

export default mul;

Once you've created modules for subtraction, addition, division, etc., you can import them and leverage the exported unique symbols for chaining operations like so:

import mul from "./mul.ts";
import sub from "./sub.ts";

const balance = 1;
const amountIn = 10;
const balanceAdjusted = balance[mul](1000)[sub](amountIn[mul](3));
console.log(balanceAdjusted);

One advantage of having chainable math operations is the ability to combine them with the optional chaining operator, especially when dealing with nullish values.

Although it's possible to achieve similar results without using symbols, this approach may not be entirely safe against potential future JavaScript updates introducing built-in Number methods like mul:

mul.ts

function value(this: number, n: number) {
  return this * n;
}

declare global {
  interface Number {
    mul: typeof value;
  }
}

Object.defineProperty(Number.prototype, "mul", { value });

export {}; // something needs to be imported or exported for modularity

import "./mul.ts";
import "./sub.ts";

const balance = 1;
const amountIn = 10;
const balanceAdjusted = balance.mul(1000).sub(amountIn.mul(3));
console.log(balanceAdjusted);

To streamline the importing process, you can consolidate all modules into one combined module:

math.ts

export { default as mul } from "./mul.ts";
export { default as sub } from "./sub.ts";
/* add other modules here */

You can then import this module and selectively utilize the desired functions:

import { mul, sub } from "./math.ts";

const balance = 1;
const amountIn = 10;
const balanceAdjusted = balance[mul](1000)[sub](amountIn[mul](3));
console.log(balanceAdjusted);

Answer 4

If you want to customize the functionality of Number.prototype, you can enhance it with additional methods to allow for chaining operations. It is generally advised against extending native objects using string property keys (refer to Why is extending native objects a bad practice?). To avoid potential conflicts and maintain uniqueness, consider using symbol property keys instead of strings.

For instance, here's a sample module that safely extends Number.prototype with a multiplication function utilizing a unique symbol, while also including the new function signature in the TypeScript Number interface:

mul.ts

const mul = Symbol("multiply");

function value(this: number, n: number) {
  return this * n;
}

declare global {
  interface Number {
    [mul]: typeof value;
  }
}

Object.defineProperty(Number.prototype, mul, { value });

export default mul;

Once you've created modules for subtraction, addition, division, etc., you can import them and leverage the exported unique symbols for chaining operations like so:

import mul from "./mul.ts";
import sub from "./sub.ts";

const balance = 1;
const amountIn = 10;
const balanceAdjusted = balance[mul](1000)[sub](amountIn[mul](3));
console.log(balanceAdjusted);

One advantage of having chainable math operations is the ability to combine them with the optional chaining operator, especially when dealing with nullish values.

Although it's possible to achieve similar results without using symbols, this approach may not be entirely safe against potential future JavaScript updates introducing built-in Number methods like mul:

mul.ts

function value(this: number, n: number) {
  return this * n;
}

declare global {
  interface Number {
    mul: typeof value;
  }
}

Object.defineProperty(Number.prototype, "mul", { value });

export {}; // something needs to be imported or exported for modularity

import "./mul.ts";
import "./sub.ts";

const balance = 1;
const amountIn = 10;
const balanceAdjusted = balance.mul(1000).sub(amountIn.mul(3));
console.log(balanceAdjusted);

To streamline the importing process, you can consolidate all modules into one combined module:

math.ts

export { default as mul } from "./mul.ts";
export { default as sub } from "./sub.ts";
/* add other modules here */

You can then import this module and selectively utilize the desired functions:

import { mul, sub } from "./math.ts";

const balance = 1;
const amountIn = 10;
const balanceAdjusted = balance[mul](1000)[sub](amountIn[mul](3));
console.log(balanceAdjusted);

Answer 5

Answer №3

Custom Number Functions Example

import { assert } from "https://deno.land/<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="81f2f5e5c1b1afb0b1b3afb1">[email protected]</a>/testing/asserts.ts";

declare global {

  /*
    Extend global Number.prototype with custom functions

    Note: This approach is considered potentially unsafe as JavaScript might implement
    these functions in the future. It is recommended to use unique function names.

  */
  interface Number {
    add(n: number): number;
    sub(n: number): number;
    mul(n: number): number;
    div(n: number): number;
    pow(n: number): number;
    sqrt(): number;
    print(): number;
  }
}

Number.prototype.add = function(this:number, n:number) {

  assert((this + n) >= this, 'ds-math-add-overflow');
  return this + n;
}

Number.prototype.sub = function(this:number, n:number) {

  assert((this - n) <= this, 'ds-math-sub-underflow');
  return this - n;
}

Number.prototype.mul = function(this:number, n:number) {

  assert(n == 0 || (this * n) / n == this, 'ds-math-mul-overflow');
  return this * n;
}

Number.prototype.div = function(this:number, n:number) {

  assert(this > 0 || n > 0, 'ds-math-div-by-zero');
  return this / n;
}

Number.prototype.pow = function(this:number, n:number) {

  assert(this > 0 && n >= 2, 'ds-math-exp-to-zero');
  return this ** n;
}

// Babylonian method for square roots
Number.prototype.sqrt = function(this:number) {

  assert(this > 0, 'ds-math-sqrt-of-zero');

  let x: number = 0;
  let y: number = this;
  let z: number = 0;

  if (y > 3) {
    z = y;
    x = y / 2 + 1;
    while (x < z) {
      z = x;
      x = (y / x + x) / 2;
    }
  } else if (y != 0) {
    z = 1;
  }
  return z;
}

Number.prototype.print = function(this:number) {

  console.log('=', this);
  return this;
}

// Usage:

let balance = 0;

balance.add(10).print().sub(1).print().mul(2).print().div(3).print().pow(4).print().sqrt().print();

Output:

= 10
= 9
= 18
= 6
= 1296
= 36

Class Implementation Example

import { assert } from "https://deno.land/<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="176463735727392627253927">[email protected]</a>/testing/asserts.ts";

class SafeMath {
  private n: number;

  constructor(start: number = 0) {
    this.n = start;
  }

  public add(y: number) {

    assert(this.n + y >= this.n, 'ds-math-add-overflow');

    let z: number = this.n + y;
    this.n = this.n + y;
    return this;
  }

  public sub(y: number) {

    assert(this.n - y <= this.n, 'ds-math-sub-underflow');

    let z: number = this.n - y;
    this.n = this.n - y;
    return this;
  }

  public mul(y: number) {

    assert(y == 0 || (this.n * y) / y == this.n, 'ds-math-mul-overflow');

    let z: number = this.n * y;
    this.n = this.n * y;
    return this;
  }

  public div(y: number) {

    assert(this.n > 0 || y > 0, 'ds-math-div-by-zero');

    let z: number = this.n / y;
    this.n = this.n / y;
    return this;
  }

  public pow(y: number) {

    assert(this.n > 0 && y >= 2, 'ds-math-exp-to-zero');

    let z: number = this.n ** y;
    this.n = this.n ** y;
    return this;
  }

  // Babylonian method for square roots
  public sqrt() {

    assert(this.n > 0, 'ds-math-sqrt-of-zero');

    let x: number = 0;
    let y: number = this.n;
    let z: number = 0;

    if (y > 3) {
      z = y;
      this.n = z;
      x = y / 2 + 1;
      while (x < z) {
        z = x;
        this.n = z
        x = (y / x + x) / 2;
      }
    } else if (y != 0) {
      z = 1;
      this.n = z
    }
    return this;
  }

  public print() {
    console.log('=', this.n);
    return this;
  }

}

// Usage:

new SafeMath(0).add(10).print().sub(1).print().mul(2).print().div(3).print().pow(4).print().sqrt().print();

Output:

= 10
= 9
= 18
= 6
= 1296
= 36

Answer 6

Custom Number Functions Example

import { assert } from "https://deno.land/<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="81f2f5e5c1b1afb0b1b3afb1">[email protected]</a>/testing/asserts.ts";

declare global {

  /*
    Extend global Number.prototype with custom functions

    Note: This approach is considered potentially unsafe as JavaScript might implement
    these functions in the future. It is recommended to use unique function names.

  */
  interface Number {
    add(n: number): number;
    sub(n: number): number;
    mul(n: number): number;
    div(n: number): number;
    pow(n: number): number;
    sqrt(): number;
    print(): number;
  }
}

Number.prototype.add = function(this:number, n:number) {

  assert((this + n) >= this, 'ds-math-add-overflow');
  return this + n;
}

Number.prototype.sub = function(this:number, n:number) {

  assert((this - n) <= this, 'ds-math-sub-underflow');
  return this - n;
}

Number.prototype.mul = function(this:number, n:number) {

  assert(n == 0 || (this * n) / n == this, 'ds-math-mul-overflow');
  return this * n;
}

Number.prototype.div = function(this:number, n:number) {

  assert(this > 0 || n > 0, 'ds-math-div-by-zero');
  return this / n;
}

Number.prototype.pow = function(this:number, n:number) {

  assert(this > 0 && n >= 2, 'ds-math-exp-to-zero');
  return this ** n;
}

// Babylonian method for square roots
Number.prototype.sqrt = function(this:number) {

  assert(this > 0, 'ds-math-sqrt-of-zero');

  let x: number = 0;
  let y: number = this;
  let z: number = 0;

  if (y > 3) {
    z = y;
    x = y / 2 + 1;
    while (x < z) {
      z = x;
      x = (y / x + x) / 2;
    }
  } else if (y != 0) {
    z = 1;
  }
  return z;
}

Number.prototype.print = function(this:number) {

  console.log('=', this);
  return this;
}

// Usage:

let balance = 0;

balance.add(10).print().sub(1).print().mul(2).print().div(3).print().pow(4).print().sqrt().print();

Output:

= 10
= 9
= 18
= 6
= 1296
= 36

Class Implementation Example

import { assert } from "https://deno.land/<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="176463735727392627253927">[email protected]</a>/testing/asserts.ts";

class SafeMath {
  private n: number;

  constructor(start: number = 0) {
    this.n = start;
  }

  public add(y: number) {

    assert(this.n + y >= this.n, 'ds-math-add-overflow');

    let z: number = this.n + y;
    this.n = this.n + y;
    return this;
  }

  public sub(y: number) {

    assert(this.n - y <= this.n, 'ds-math-sub-underflow');

    let z: number = this.n - y;
    this.n = this.n - y;
    return this;
  }

  public mul(y: number) {

    assert(y == 0 || (this.n * y) / y == this.n, 'ds-math-mul-overflow');

    let z: number = this.n * y;
    this.n = this.n * y;
    return this;
  }

  public div(y: number) {

    assert(this.n > 0 || y > 0, 'ds-math-div-by-zero');

    let z: number = this.n / y;
    this.n = this.n / y;
    return this;
  }

  public pow(y: number) {

    assert(this.n > 0 && y >= 2, 'ds-math-exp-to-zero');

    let z: number = this.n ** y;
    this.n = this.n ** y;
    return this;
  }

  // Babylonian method for square roots
  public sqrt() {

    assert(this.n > 0, 'ds-math-sqrt-of-zero');

    let x: number = 0;
    let y: number = this.n;
    let z: number = 0;

    if (y > 3) {
      z = y;
      this.n = z;
      x = y / 2 + 1;
      while (x < z) {
        z = x;
        this.n = z
        x = (y / x + x) / 2;
      }
    } else if (y != 0) {
      z = 1;
      this.n = z
    }
    return this;
  }

  public print() {
    console.log('=', this.n);
    return this;
  }

}

// Usage:

new SafeMath(0).add(10).print().sub(1).print().mul(2).print().div(3).print().pow(4).print().sqrt().print();

Output:

= 10
= 9
= 18
= 6
= 1296
= 36

Creating chainable calculations with the SafeMath class

Answer №1

Answer №2

Answer №3

Custom Number Functions Example

Class Implementation Example

Similar questions

Use jQuery to retrieve the number of items that have been selected in an ASP ListBox

Calculating the size of an array based on its attributes

Generate your API with the NODEJS Express application generator

An unexpected error occurred in the Angular unit and integration tests, throwing off the script

Converting a space-separated string into tags-input (treating each segment as a separate tag) in AngularJS

Unable to send multiple cookies using custom headers in Next.js configuration

Tips for loading JavaScript files after a view has been rendered in Angular

Sort and incorporate elements by multiple strings present in an array

Arrow functions in ECMAScript 6

Issues with jQuery's .attr function not resolving

Text field suddenly loses focus upon entering a single character

Unable to validate JWT - UnhandledPromiseRejectionWarning: JsonWebTokenError: invalid token format

A new marker has been created on the Ajax Google Map, however, the old marker is still displaying as

A guide on simulating childprocess.exec in TypeScript

A step-by-step guide on accessing and displaying local Storage JSON data in the index.html file of an Angular project, showcasing it on the

What is the best way to manage the back button using jQuery?

Determine the presence of a value in Javascript

Conceal the element if the output of express is void

MacGyver's innovative Angular mac-autocomplete directive fails to properly auto-complete

What is the best way to retrieve data from multiple pages of a JSON API in one go?