|x|₁ = ∑|xᵢ|

@return float
@link https://en.wikipedia.org/wiki/Norm_(mathematics)#Taxicab_norm_or_Manhattan_norm
17651
public function l1Norm(): float
    {
        return array_reduce($this->toArray(), function (float $carry, float $value) {
            return $carry + abs($value);
        }, 0);
    }
698271
public function toFloat(): float
    {
        $frac = $this->numerator / $this->denominator;
        $sum  = $this->whole + $frac;
        return $sum;
    }
256457
public function getFloatMinor()
    {
        if ($this->startsWith($this->minor, '0'))
            return (float) ('0.'.substr($this->minor, 1));
        return (float) $this->minor;
    }
602380
public static float cs_norm(Scs A) {
        int p, j, n, Ap[];
        float Ax[], norm = 0, s;
        if (!Scs_util.CS_CSC(A) || A.x == null)
            return (-1); /* check inputs */
        n = A.n;
        Ap = A.p;
        Ax = A.x;
        for (j = 0; j < n; j++) {
            for (s = 0, p = Ap[j]; p < Ap[j + 1]; p++)
                s += Math.abs(Ax[p]);
            norm = Math.max(norm, s);
        }
        return (norm);
    }
1318379
public function pdf(float $x): float
    {
        $a = $this->a;
        $b = $this->b;

        if ($x < $a || $x > $b) {
            return 0;
        }

        return 1 / ($b - $a);
    }
1110019
public function getZ() : ?float 
    {
        if ( ! $this->hasZ()) {
            $this->setZ($this->getDefaultZ());
        }
        return $this->z;
    }
504106
public function maxNorm(): float
    {
        return array_reduce($this->toArray(), function (float $carry, float $value) {
            $value = abs($value);

            return $carry > $value ? $carry : $value;
        }, -INF);
    }
514145
public function x()
    {
        // Load file
        $file = new \SplFileObject($this->storage('finals.all'));

        // Get instance MJD, and MJD at line 0
        $mjdQ = $this->mjd;
        $mjd0 = (int)substr($file->getCurrentLine(), 7, 8);

        // Check for requested MJD before first date
        if ($mjdQ < $mjd0) {
            return false;
        }

        // Determine nearest center pointer
        $p = $mjdQ - $mjd0 - 1;

        // Fix for values within |n| of lower bound
        if ($p < static::INTERP_C && $p > -static::INTERP_C) {
            $p = static::INTERP_C;
        }

        // Compile dataset
        $ds = [];
        for ($i = $p - static::INTERP_C; $i < $p + static::INTERP_C; $i++) {
            $file->seek($i);
            $line = $file->getCurrentLine();

            // Parse data from line
            $mjd = substr($line, 7, 8);
            $xf  = substr($line, 136, 9);
            $xp  = substr($line, 18, 9);

            // Use final value first, if not present use prediction
            $x = trim($xf) ? $xf : $xp;

            // Check if no dut1 data, error
            if (trim($x) == '') {
                return false;
            }

            // Add the data
            $ds[$i - $p + static::INTERP_C]['x'] = (float)$mjd;
            $ds[$i - $p + static::INTERP_C]['y'] = (float)$x;
        }

        // Interpolate pole x
        return $this->lagrangeInterp($mjdQ, $ds);
    }
1331573
function normcdf(x) {
  var a1 = 0.398942280444;
  var a2 = 0.399903438504;
  var a3 = 5.75885480458;
  var a4 = 29.8213557808;
  var a5 = 2.62433121679;
  var a6 = 48.6959930692;
  var a7 = 5.92885724438;
  var b0 = 0.398942280385;
  var b1 = 3.8052E-08;
  var b2 = 1.00000615302;
  var b3 = 3.98064794E-04;
  var b4 = 1.98615381364;
  var b5 = 0.151679116635;
  var b6 = 5.29330324926;
  var b7 = 4.8385912808;
  var b8 = 15.1508972451;
  var b9 = 0.742380924027;
  var b10 = 30.789933034;
  var b11 = 3.99019417011;
  var q;
  var y;
  var absx = Math.abs(x);

  if (absx <= 1.28) {
    y = 0.5 * x * x;
    q = 0.5 - absx * (a1 -
      a2 * y / (y + a3 -
      a4 / (y + a5 +
      a6 / (y + a7))));
  } else if (absx <= 12.7) {
    y = 0.5 * x * x;
    q = Math.exp(-y) * b0 / (absx - b1
      + b2 / (absx + b3
      + b4 / (absx - b5
      + b6 / (absx + b7
      - b8 / (absx + b9
      + b10 / (absx + b11))))));
  } else {
    q = 0.0;
  }

  if (x < 0.0)
  {
    return q;
  }
  return 1.0 - q;
}
394548
public double norm()
    {
        double t = 0;

        for (int r = 0; r < nRows; ++r) {
            double v = values[r][0];
            t += v*v;
        }

        return (double) Math.sqrt(t);
    }
393615
public double norm()
    {
        double t = 0;
        for (int c = 0; c < nCols; ++c) {
            double v = values[0][c];
            t += v*v;
        }

        return (double) Math.sqrt(t);
    }
28801
public static float min(float[] x) {
        float m = Float.POSITIVE_INFINITY;

        for (float n : x) {
            if (n < m) {
                m = n;
            }
        }

        return m;
    }
996232
function equals($x)
    {
        switch (MATH_BIGINTEGER_MODE) {
            case MATH_BIGINTEGER_MODE_GMP:
                return gmp_cmp($this->value, $x->value) == 0;
            default:
                return $this->value === $x->value && $this->is_negative == $x->is_negative;
        }
    }
894473
public double normF () {
      double f = 0;
      for (int i = 0; i < m; i++) {
         for (int j = 0; j < n; j++) {
            f = Maths.hypot(f,A[i][j]);
         }
      }
      return f;
   }
223825
public static BigFloat tanh(BigFloat x) {
		if (x.isNaN() || x.isZero())
			return x;
		if (x.isInfinity())
			return x == POSITIVE_INFINITY ? x.context.ONE : x.context.NEGATIVE_ONE;
		return x.context.valueOf(BigDecimalMath.tanh(x.value, x.context.mathContext));
	}
497307
public function getGamma()
    {
        if (!preg_match('/^[0-9]\.*[0-9]*$/', $this->gam)) {
            return;
        }

        if ($this->gam < 0.1 or $this->gam > 9.99) {
            return;
        }

        return (double) $this->gam;
    }
982994
public float floatValue() {
        BigDecimal adivb = (new BigDecimal(a)).divide(new BigDecimal(b), MathContext.DECIMAL128);
        return adivb.floatValue();
    }