Source: model/Point.js

  1. /**
  2.  * @file Class Point
  3.  * @version March 12, 2017
  4.  *
  5.  * @author Olivier Pirson --- http://www.opimedia.be/
  6.  * @license GPLv3 --- Copyright (C) 2017 Olivier Pirson
  7.  */
  9. /**
  10.  * A point,
  11.  * represented by its cartesian coordinates.
  12.  */
  13. class Point {
  14.     /**
  15.      * Constructs a point of cartesian coordinates (x=a, y=b).
  16.      *
  17.      * @param {number} a
  18.      * @param {number} b
  19.      */
  20.     constructor(a, b) {
  21.         assert(typeof a === "number", a);
  22.         assert(typeof b === "number", b);
  24.         this._x = a;
  25.         this._y = b;
  26.     }
  29.     /**
  30.      * Returns the horizontal coordinate of the cartesian coordinates.
  31.      *
  32.      * @returns {number}
  33.      */
  34.     get x() {
  35.         if (this._x === null) {
  36.             this._x = this.r*Math.cos(this.phi);
  37.         }
  39.         return this._x;
  40.     }
  43.     /**
  44.      * Returns the vertical coordinate of the cartesian coordinates.
  45.      *
  46.      * @returns {number}
  47.      */
  48.     get y() {
  49.         if (this._y === null) {
  50.             this._y = this.r*Math.sin(this.phi);
  51.         }
  53.         return this._y;
  54.     }
  58.     /**
  59.      * Returns a new point that is the sum.
  60.      *
  61.      * @param {Point} other
  62.      *
  63.      * @returns {Point}
  64.      */
  65.     add(other) {
  66.         assert(other instanceof Point, other);
  68.         return new Point(this.x + other.x, this.y + other.y);
  69.     }
  72.     /**
  73.      * Compare two points before with x coordinate
  74.      * and maybe after with y coordinate.
  75.      *
  76.      * @param {Point} other
  77.      *
  78.      * @returns {number} -1, 0 or 1
  79.      */
  80.     compare(other) {
  81.         assert(other instanceof Point, other);
  83.         const compX = compare(this.x, other.x);
  85.         return (compX !== 0
  86.                 ? compX
  87.                 : compare(this.y, other.y));
  88.     }
  91.     /**
  92.      * Returns the distance between the two points.
  93.      *
  94.      * @param {Point} other
  95.      *
  96.      * @returns {number} >= 0
  97.      */
  98.     distance(other) {
  99.         assert(other instanceof Point, other);
  101.         return Math.sqrt(this.distanceSqr(other));
  102.     }
  105.     /**
  106.      * Returns the square of the distance between the two points.
  107.      *
  108.      * @param {Point} other
  109.      *
  110.      * @returns {number} >= 0
  111.      */
  112.     distanceSqr(other) {
  113.         assert(other instanceof Point, other);
  115.         const diffX = this._x - other._x;
  116.         const diffY = this._y - other._y;
  118.         return diffX*diffX + diffY*diffY;
  119.     }
  122.     /**
  123.      * Returns the distance to (0, 0).
  124.      *
  125.      * @returns {number} >= 0
  126.      */
  127.     distanceTo0() {
  128.         return Math.sqrt(this.distanceTo0Sqr());
  129.     }
  132.     /**
  133.      * Returns the square of the distance to (0, 0).
  134.      *
  135.      * @returns {number} >= 0
  136.      */
  137.     distanceTo0Sqr() {
  138.         return this._x*this._x + this._y*this._y;
  139.     }
  142.     /**
  143.      * Returns true iff the point is equals to the point other,
  144.      * namely iff they are same cartesian coordinates.
  145.      *
  146.      * @param {Point} other
  147.      *
  148.      * @returns {boolean}
  149.      */
  150.     isEquals(other) {
  151.         assert(other instanceof Point, other);
  153.         return (this.x === other.x) && (this.y === other.y);
  154.     }
  157.     /**
  158.      * Returns a new point multiply by the scalar n.
  159.      *
  160.      * @returns {Point}
  161.      */
  162.     mulScalar(n) {
  163.         assert(typeof n === "number", n);
  165.         return new Point(this.x*n, this.y*n);
  166.     }
  169.     /**
  170.      * Returns a new point that is the difference.
  171.      *
  172.      * @param {Point} other
  173.      *
  174.      * @returns {Point}
  175.      */
  176.     sub(other) {
  177.         assert(other instanceof Point, other);
  179.         return new Point(this.x - other.x, this.y - other.y);
  180.     }
  183.     /**
  184.      * Returns a string cartesian representation of the point.
  185.      *
  186.      * Each number is represented with at most precision figures after the decimal point.
  187.      *
  188.      * @returns {String}
  189.      */
  190.     toString(precision=2) {
  191.         assert(Number.isInteger(precision), precision);
  192.         assert(precision >= 0, precision);
  194.         function format(n) {
  195.             return (Number.isInteger(n)
  196.                     ? n.toString()
  197.                     : n.toFixed(precision));
  198.         }
  200.         return "(" + format(this.x) + ", " + format(this.y) + ")";
  201.     }
  202. }