Class: MathUtil

• new MathUtil()

• new MathUtil()

• Static get epsilon(): number

constant for epsilon equal to 1E-10

number

• Static get logMin(): number

constant for minimum logarithmic value to be display equal to 1E-10

number

• Static get quickSort(): (array: any[] | number[], lo: number, hi: number, comparator: Comparator, swap: Swap) => void

Quick sort (in-place).

fn

▸ (array, lo, hi, comparator, swap): void

Quick sort (in-place).

void

• Static get sortPointsClockwise(): (xArray: number[], yArray: number[], isClockwise?: boolean) => void

Sort given array clockwise around their center point.

fn

▸ (xArray, yArray, isClockwise?): void

Sort given array clockwise around their center point.

void

▸ Static calcCubicBezier(first, p1, p2, last, flatness?): Point[]

Bezier curves are often used to model smooth curves. calcCubicBezier Performs cubic Bezier approximation. The control points P1 and P2 are only used to provide directional information.The arc or circle is divided into four equal sections and each section fit to a cubic Bézier curve. When points are spaced far apart approximation is performed based on the precision(flatness) and control points on the same side of vector.

Point[]

array of interpolated points if "param" is undefined or is an Array instance

▸ Static calculateNeatLimits(min, max, logScale?, centerOnZeroOnNegativeMin?, splitOnZero?): Range

This function computes human readable limits so that the returned interval is easily apprehended by the user.
To do so, it will compute a minimum and maximum that can be easily divided by 2.
Which means the user will immediately guess the mid and quarter values.

The purpose of this function is not to provide accurately rounded limits but limits that will be easily apprehended.
Using the given limits can virtually remove the necessity of displaying the intermediates labels on a axis.

For example it will return [0, 4000] for the values [790, 3050].
The user will easily guess the mid value to be 2000.

Range

The computed neat limits

▸ Static calculateNiceLimits(min, max, desiredNumberOfTicks, minPadding?, maxPadding?): Limits

Create a "nice" range based on "Algorithm for Optimal Scaling on a Chart Axis".

Limits

calculated limits

▸ Static calculateRoundedLimits(min, max, marginPercentage?, marginPercentageTolerance?): Range

Computes rounded limits using margin percentages as constraints.

This function tries to compute a 'smart' range that includes the given min/max.
To do so it will try to simplify the decimal part of the given values to the closest value.
The original range is always contained in the returned range, meaning that the returned 'low' is lesser than the given min and the returned 'high' is greater than the given max.

The given margin parameters will be used to constrain rounding process:

• Margin:
  The margin percentage determines how much margin the algorithm will try to introduce.
  If the given margin percentage is 10%, then the returned 'high'' will be around:
  high = max + 10% * (max - min).
  


• Margin tolerance:
  The margin tolerance percentage determines how much the 'smart rounding' process can change the value computed above.
  If the given margin percentage is 4%, then the returned 'high' will be in the range:
  [high - 0.02 * (max - min), high + 0.04 * (max - min)].
  Note that margin tolerance is applied differently for inner tolerance.
  

  ------------------|-----------<----|-------->
  max             +10% (margin)
  -2%            +4% (margin tolerance) ------------------|-----------<----|--------> high (before rounding) 
  Example
  import {MathUtil} from '@int/geotoolkit/util/MathUtil';
  // With default margin :
  MathUtil.calculateRoundedLimits(347.242, 372.110); // returns Range(345, 374);
  
  // With bigger margin (10%) :
  MathUtil.calculateRoundedLimits(347.242, 372.110, 0.10); // returns Range(344, 375);
  
  // With values close to zero :
  MathUtil.calculateRoundedLimits(-0.0041, 0.012); // returns Range(-0.005, 0.013);
  Parameters
  Name 
  Type 
  Description 
  min
  number
  The minimum value to be rounded
  max
  number
  The maximum value to be rounded
  Optional marginPercentage
  number
  Percentage of margin desired
  Optional marginPercentageTolerance
  number
  Percentage of margin tolerance desired
  Returns
  Range
  The computed range
  clamp
  ▸ Static clamp(value, min, max): number
  Clamp the value to the range
  Parameters
  Name 
  Type 
  Description 
  value
  number
  current value
  min
  number
  minimum value
  max
  number
  maximum value
  Returns
  number
  clamped value
  computeStatistics
  ▸ Static computeStatistics(array): Statistics
  Compute Statistics for a collection
  Parameters
  Name 
  Type 
  Description 
  array
  number[]
  raw number array
  Returns
  Statistics
  degToRad
  ▸ Static degToRad(deg): number
  Convert degree to radians
  Parameters
  Name 
  Type 
  Description 
  deg
  number
  The angle in degrees
  Returns
  number
  The angle in radians
  equals
  ▸ Static equals(v1, v2, epsilon?): boolean
  Compare two values with specified precision
  Parameters
  Name 
  Type 
  Description 
  v1
  number
  1st number to compare
  v2
  number
  2nd number to compare
  Optional epsilon
  number
  difference bet 2 numbers to compare
  Returns
  boolean
  findIndex
  ▸ Static findIndex<T>(value, values, fromIndex?, toIndex?, compareFunction?): number
  Uses binary search to find an index of given value. If given value is found, it returns the exact index. If given value is not found it returns ~[next closest index].
  Type parameters
  Name
  T
  Parameters
  Name 
  Type 
  Description 
  value
  T
  object to find
  values
  T[]
  sorted array on objects
  Optional fromIndex
  number
  index to start the search
  Optional toIndex
  number
  index to end search scope
  Optional compareFunction
  (x: T, y: T) => number | Order
  compare function that defines the sort order. If omitted, the object type must be number. The second parameter passed to this compareFunction is the value passed to findIndex(). OR the data order. Ascending by default.
  Returns
  number
  ▸ Static findIndex<T>(value, values, fromIndex?, toIndex?, compareFunction?): number
  Type parameters
  Name
  T
  Parameters
  Name 
  Type 
  value
  number
  values
  T[]
  Optional fromIndex
  number
  Optional toIndex
  number
  Optional compareFunction
  Order | (x: T, y: number) => number
  Returns
  number
  findNiceLimits
  ▸ Static findNiceLimits(min, max, modelStep, minPadding?, maxPadding?): Limits
  Find a "nice" settings based on "Algorithm for Optimal Scaling on a Chart Axis".
  Parameters
  Name 
  Type 
  Description 
  min
  number
  minimum value
  max
  number
  maximum value
  modelStep
  number
  desired model space between ticks
  Optional minPadding
  boolean
  add step padding at first or not
  Optional maxPadding
  boolean
  add step padding at the end or not
  Returns
  Limits
  calculated limits
  getCentile
  ▸ Static getCentile(values, centileNum): number
  Get centile
  Parameters
  Name 
  Type 
  Description 
  values
  number[]
  the percent value
  centileNum
  number
  percentile
  Returns
  number
  getLimits
  ▸ Static getLimits(arr, init?, nullvalue?): number[]
  Return the min and max values of a given array.
   This function ignores NaN and null values.
  Parameters
  Name 
  Type 
  Description 
  arr
  number[]
  represents the array
  Optional init
  number[]
  represents the initials min and max values: [min, max]
  Optional nullvalue
  number
  A nullvalue to ignore, note that null and NaN are ignored
  Returns
  number[]
  An array containing the [min, max]
  getMax
  ▸ Static getMax(arr, init?, nullvalue?): number
  Return the max values of a given array.
   This function ignores NaN and null values.
  Parameters
  Name 
  Type 
  Description 
  arr
  number[]
  represents the array.
  Optional init
  number
  represents the initial max value
  Optional nullvalue
  number
  A nullvalue to ignore, note that null and NaN are ignored
  Returns
  number
  the minimum valid value in the given array.
  getMin
  ▸ Static getMin(arr, init?, nullvalue?): number
  Return the min value of a given array. it internally filter NaN and null values.
  Parameters
  Name 
  Type 
  Description 
  arr
  number[]
  represents the array.
  Optional init
  number
  represents the initial min value
  Optional nullvalue
  number
  A nullvalue to ignore, note that null and NaN are ignored
  Returns
  number
  the minimum valid value in the given array.
  getSeededRandom
  ▸ Static getSeededRandom(min?, max?, seed?): number
  Used for tutorials to create a reproducible random value set.
  Parameters
  Name 
  Type 
  Description 
  Optional min
  number
  value of random
  Optional max
  number
  value of random
  Optional seed
  number
  seed
  Returns
  number
  getWeightedArithmeticMean
  ▸ Static getWeightedArithmeticMean(intervals, weights, power?): number
  Gets weighted arithmetic mean (or weighted average)
  Throws
  Error if input arrays are not valid or sum of weights is zero
  Parameters
  Name 
  Type 
  Description 
  intervals
  number[]
  array of intervals
  weights
  number[]
  array of their respective weights
  Optional power
  number
  weight power
  Returns
  number
  weighted arithmetic mean
  isNumber
  ▸ Static isNumber(value): value is number
  Checks whether value is a finite number.
  Parameters
  Name 
  Type 
  Description 
  value
  any
  value to test
  Returns
  value is number
  isNumeric
  ▸ Static isNumeric(value): value is number
  Checks whether value is a finite number.
  Parameters
  Name 
  Type 
  Description 
  value
  any
  value to test
  Returns
  value is number
  isPlatformLittleEndian
  ▸ Static isPlatformLittleEndian(): boolean
  Checks if current platform is little endian
  Returns
  boolean
  log10
  ▸ Static log10(val, precision?, handlenegative?): number
  Calculates log base 10
  Example
  import {MathUtil} from '@int/geotoolkit/util/MathUtil';
  MathUtil.log10(-10, null, true); // will give -1 result and MathUtil.log10(-10) will be NaN
  Parameters
  Name 
  Type 
  Description 
  val
  number
  value to calculate log base 10
  Optional precision
  number
  the number of digits after the decimal point
  Optional handlenegative
  boolean
  set true if handling of negative value and 0 is required when mapping
  Returns
  number
  niceNumber
  ▸ Static niceNumber(value, round?): number
  Returns a "nice" number approximately equal to range Rounds the number if round = true takes the ceiling if round = false.
  Parameters
  Name 
  Type 
  Description 
  value
  number
  input number
  Optional round
  boolean
  round value
  Returns
  number
  output number
  normalizeAngle
  ▸ Static normalizeAngle(angle): number
  Normalizes the provided angle to be in range [0, 2*PI]
  Parameters
  Name 
  Type 
  Description 
  angle
  number
  Angle to normalize
  Returns
  number
  radToDeg
  ▸ Static radToDeg(rad): number
  Convert radians to degree
  Parameters
  Name 
  Type 
  Description 
  rad
  number
  The angle in radians
  Returns
  number
  The angle in degrees
  round
  ▸ Static round(value, base?): number
  Rounds value with the provided accuracy base
  Example
  import {MathUtil} from '@int/geotoolkit/util/MathUtil';
  MathUtil.round(12.3456, 1000); // 12.346, rounds to 1/1000 accuracy
  MathUtil.round(12.3456, 100); // 12.35, rounds to 1/100 accuracy
  MathUtil.round(12.3456, 10); // 12.3, rounds to 1/10 accuracy
  MathUtil.round(12.3456, 4); // 12.25, rounds to 1/4 accuracy
  Parameters
  Name 
  Type 
  Description 
  value
  number
  value to round
  Optional base
  number
  accuracy base to round
  Returns
  number
  roundTo
  ▸ Static roundTo(src, precision): number
  Rounds "src" to relative (see example below) "precision"
  Example
  import {MathUtil} from '@int/geotoolkit/util/MathUtil';
  const a = 0.0000056789;
  const resA = MathUtil.roundTo(a, 2); // resA = 0.00000568
  const b = 56789.56789;
  const resB = MathUtil.roundTo(b, 2); // resB = 56800
  Parameters
  Name 
  Type 
  Description 
  src
  number
  source value to be rounded
  precision
  number
  relative precision
  Returns
  number
  rounded value
  sign
  ▸ Static sign(a): number
  Get sign of specified value
  Parameters
  Name 
  Type 
  Description 
  a
  number
  current value
  Returns
  number
  -1 for negative | 0 for zero | +1 for positive