|x|∞ = max |x|

Max norm (infinity norm) (|x|∞)

@return float
504106
public function maxNorm(): float
    {
        return array_reduce($this->toArray(), function (float $carry, float $value) {
            $value = abs($value);

            return $carry > $value ? $carry : $value;
        }, -INF);
    }
862220
private function norm()
    {
        $this->str = preg_replace("#^\s*#u", '', $this->str);
        $this->str = preg_replace("#\s*$#u", '', $this->str);
        $this->str = preg_replace("#\s+#u", ' ', $this->str);
        $this->str = preg_replace('#,$#u', ' ', $this->str);

        return true;
    }
500177
public function interpolate( $x )
	{
		$sum	= 0;
		$values	= array_values( $this->data );
		$expressions	= $this->getExpressions();
		for( $i=0; $i<count( $expressions ); $i++ )
		{
			$expression	= $expressions[$i];
			$formula	= new Alg_Math_Formula( $expression, array( "x" ) );
			$value	= $formula->getValue( 2 );
			$sum	+= $values[$i] * $value;
		}
		return $sum;
	}
1023711
public function getMinValue()
    {
        if ($this->isUnsigned) {
            return 0;
        }

        if (!is_null($value = $this->getMaxValue())) {
            return ($value * -1) - ($this->isDecimal() ? 0 : 1);
        }

        return null;
    }
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);
    }
860564
public function getLimit()
    {
        if ($this->max > 0) {
            return min($this->max, $this->limit);
        }

        return $this->limit;
    }
541208
protected function getMax()
    {
        $params = array_filter(func_get_args() ?: [], function ($arg) {
            return !is_null($arg) && $arg !== "";
        });

        return count($params) > 0 ? max($params) : null;
    }
372966
function getMaxY() {
    if (self.options.maxY) {
      return self.options.maxY;
    }

    var max = -Infinity;

    for(let i = 0; i < data.length; i++) {
      if (data[i].y.length) {
        var current = _.max(data[i].y, parseFloat);
        if (current > max) {
          max = current;
        }
      }
    }

    return max + (max - self.options.minY) * 0.2;
  }
201563
def max(x, y, context=None):
    
    return _apply_function_in_current_context(
        BigFloat,
        mpfr.mpfr_max,
        (
            BigFloat._implicit_convert(x),
            BigFloat._implicit_convert(y),
        ),
        context,
    )
353352
def norm(a, ref1, ref2):
    
    ref = ref1[valid(ref1, ref2)]
    return (a-ref.min())/(ref.max()-ref.min())
823124
public function isOptional()
    {
        $min = (int) $this->getConfigurationValue('repeat_min');
        $max = (int) $this->getConfigurationValue('repeat_max');

        return $min === 0 && $max > 0;
    }
699402
def _call(self, x):
        """"""
        x_norm = self.__norm(x)

        if x_norm > 1:
            return np.inf
        else:
            return 0
1073405
function limit(out, a, max) {
  var mSq = a[0] * a[0] + a[1] * a[1];

  if (mSq > max * max) {
    var n = Math.sqrt(mSq);
    out[0] = a[0] / n * max;
    out[1] = a[1] / n * max;
  } else {
    out[0] = a[0];
    out[1] = a[1];
  }

  return out;
}
451397
protected function _getMax()
	{
		$max = 0;
		if (!empty($this->_tagsArray)) {
			$p_size = 0;
			foreach ($this->_tagsArray as $cKey => $cVal) {
				$c_size = $cVal['size'];
				if ($c_size > $p_size) {
					$max = $c_size;
					$p_size = $c_size;
				}
			}
		}
		return $max;
	}
653208
public function max()
    {
        $max = null;
        $first = false;
        foreach ($this as $v) {
            if (!$first || $v > $max) {
                $max = $v;
                $first = true;
            }
        }
        return $max;
    }
871113
def Norm2(self):
    
    sum = self.x * self.x + self.y * self.y + self.z * self.z
    return math.sqrt(float(sum))
758350
public static float max(float[] x) {
        float m = Float.NEGATIVE_INFINITY;

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

        return m;
    }