Class: MathUtil

• [new MathUtil()](/solutions/geotoolkit/GeoToolkit_JS/apis/classes/geotoolkit.util.mathutil.mathutil.md#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.<br> To do so, it will compute a minimum and maximum that can be easily divided by 2.<br> Which means the user will immediately guess the mid and quarter values.<br> <br> The purpose of this function is not to provide accurately rounded limits but limits that will be easily apprehended.<br> Using the given limits can virtually remove the necessity of displaying the intermediates labels on a axis.<br> <br> For example it will return [0, 4000] for the values [790, 3050].<br> The user will easily guess the mid value to be 2000.<br>

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.<br> <br> This function tries to compute a 'smart' range that includes the given min/max.<br> To do so it will try to simplify the decimal part of the given values to the closest value.<br> 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.<br> <br> The given margin parameters will be used to constrain rounding process:<br> <ul> <li>Margin:<br> The margin percentage determines how much margin the algorithm will try to introduce.<br> If the given margin percentage is 10%, then the returned 'high'' will be around:<br> <i>high = max + 10% * (max - min)</i>.<br> </li> <br> <li>Margin tolerance:<br> The margin tolerance percentage determines how much the 'smart rounding' process can change the value computed above.<br> If the given margin percentage is 4%, then the returned 'high' will be in the range:<br> <i>[high - <b>0.02</b> * (max - min), high + <b>0.04</b> * (max - min)]</i>.<br> Note that margin tolerance is applied differently for inner tolerance.<br> <pre> ------------------|-----------<----|--------> max +10% (margin)

-2% +4% (margin tolerance) ------------------|-----------<----|--------> high (before rounding) </pre>

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);

Range

The computed range

▸ Static clamp(value, min, max): number

Clamp the value to the range

number

clamped value

▸ Static computeStatistics(array): Statistics

Compute Statistics for a collection

Statistics

▸ Static degToRad(deg): number

Convert degree to radians

number

The angle in radians

▸ Static equals(v1, v2, epsilon?): boolean

Compare two values with specified precision

boolean

▸ Static findIndex<T&gt;(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].

number

▸ Static findIndex<T&gt;(value, values, fromIndex?, toIndex?, compareFunction?): number

number

▸ Static findNiceLimits(min, max, modelStep, minPadding?, maxPadding?): Limits

Find a "nice" settings based on "Algorithm for Optimal Scaling on a Chart Axis".

Limits

calculated limits

▸ Static getCentile(values, centileNum): number

Get centile

number

▸ Static getLimits(arr, init?, nullvalue?): number[]

Return the min and max values of a given array.<br> This function ignores NaN and null values.

number[]

An array containing the [min, max]

▸ Static getMax(arr, init?, nullvalue?): number

Return the max values of a given array.<br> This function ignores NaN and null values.

number

the minimum valid value in the given array.

▸ Static getMin(arr, init?, nullvalue?): number

Return the min value of a given array. it internally filter NaN and null values.

number

the minimum valid value in the given array.

▸ Static getSeededRandom(min?, max?, seed?): number

Used for tutorials to create a reproducible random value set.

number

▸ 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

number

weighted arithmetic mean

▸ Static isNumber(value): value is number

Checks whether value is a finite number.

value is number

▸ Static isNumeric(value): value is number

Checks whether value is a finite number.

value is number

▸ Static isPlatformLittleEndian(): boolean

Checks if current platform is little endian

boolean

▸ 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

number

▸ 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.

number

output number

▸ Static normalizeAngle(angle): number

Normalizes the provided angle to be in range [0, 2*PI]

number

▸ Static radToDeg(rad): number

Convert radians to degree

number

The angle in degrees

▸ 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

number

▸ 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

number

rounded value

▸ Static sign(a): number

Get sign of specified value

number

-1 for negative | 0 for zero | +1 for positive