Return the maximum C.R.A.P. index

@return int
15840
public function getMaximumCRAPIndex() {
		$maximumCRAP = 0;
		foreach ($this->getFiles() as $file) {
			foreach ($file->getLines() as $line) {
				if ($line->getType() == CloverLine::TYPE_METHOD) {
					if ($line->getCrap() > $maximumCRAP) {
						$maximumCRAP = $line->getCRAP();
					}
				}
			}
		}
		foreach ($this->getPackages() as $package) {
			foreach ($package->getFiles() as $file) {
				foreach ($file->getLines() as $line) {
					if ($line->getType() == CloverLine::TYPE_METHOD) {
						if ($line->getCrap() > $maximumCRAP) {
							$maximumCRAP = $line->getCRAP();
						}
					}
				}
			}
		}

		return $maximumCRAP;
	}
359445
def max(self):
        
        return int(self._max) if not np.isinf(self._max) else self._max
1002586
public function getMaxHostHex()
    {
        if ($this->network_size === 32 || $this->network_size === 31) {
            return implode('', array_map(
                function ($quad) {
                    return sprintf(self::FORMAT_HEX, $quad);
                },
                $this->quads
            ));
        }
        return $this->maxHostCalculation(self::FORMAT_HEX);
    }
789419
public function getUsedDepth(): int
    {
        $maxDepth = 0;

        /** @var PackedItem $item */
        foreach ($this->items as $item) {
            $maxDepth = max($maxDepth, $item->getZ() + $item->getDepth());
        }

        return $maxDepth;
    }
439294
public static function getKeyIndex(): int
    {
        if (self::$keyIndex == PHP_INT_MAX) {
            self::$keyIndex = 0;
        } else {
            self::$keyIndex++;
        }

        return self::$keyIndex;
    }
192731
protected function getMaxTmpUploadFileSize()
    {

        $actTmpUploadFileSize = 0;
        $confKey = 'ImageSizes';

        // get all config keys "*ImageSizes"
        $imageSizes = Configure::read('app');
        foreach (array_keys($imageSizes) as $appKey) {
            if (strlen($appKey) < strlen($confKey) // prevent warnings of strrpos()
                || strrpos($appKey, $confKey, strlen($confKey) * (-1)) === false
                || !is_array($imageSizes[$appKey])
            ) {
                continue;
            }

            foreach ($imageSizes[$appKey] as $key => $value) {
                if ($key <= $actTmpUploadFileSize) {
                    continue;
                }
                $actTmpUploadFileSize = $key;
            }
        }

        return $actTmpUploadFileSize;
    }
956031
public function getDepth()
    {
        return array_reduce(
            $this->cartLines->toArray(),
            function ($depth, CartLineInterface $cartLine) {
                return max($depth, $cartLine->getDepth());
            },
            0
        );
    }
967541
protected function _getMax()
    {
        $field = $this->_config['right'];
        $rightField = $this->_config['rightField'];
        $edge = $this->_scope($this->_table->find())
            ->select([$field])
            ->orderDesc($rightField)
            ->first();

        if (empty($edge->{$field})) {
            return 0;
        }

        return $edge->{$field};
    }
1245028
protected function getMaximumRequirement()
    {
        $maximumLength = $this->config->get('concrete.user.password.maximum');

        return $maximumLength ? $this->app->make(MaximumLengthValidator::class, [$maximumLength]) : null;
    }
347284
public function getMaxId()
    {

        try {
            $result = app('db')->connection('mysql')->select("select max(id) maxid from " . config("database.mysql_workers"));

        } catch (\Exception $e) {
            Log::info('c=CopydataApiController f=getMaxId  msg=' . $e->getMessage());
            return false;
        }

        $max = $result[0]->maxid;
        return (int)$max;
    }
532505
public function getMaxUploadSize()
    {
        $maxUpload = (int)(ini_get('upload_max_filesize'));
        $maxPost = (int)(ini_get('post_max_size'));
        $memoryLimit = (int)(ini_get('memory_limit'));
        return min($maxUpload, $maxPost, $memoryLimit);
    }
386692
public function getLimit()
    {
        if (!is_null($this->suppliedLimit)) {
            return $this->suppliedLimit;
        } elseif (!is_null($this->entityLimit)) {
            return $this->entityLimit;
        }
        return false;
    }
101694
public function getMaxValue()
    {
        $values = $this->values->toArray();

        uasort($values, $this->cmpValues('getName'));

        return end($values);
    }
1354359
public function getMaxOpenFilesLimit()
    {
        static $limit = null;

        if (null === $limit) {
            $process = new Process('ulimit -n');
            $process->run();

            if ($process->isSuccessful()) {
                $limit = (int) trim($process->getOutput());
            }

            unset($process);
        }

        return $limit;
    }
231806
public function getCountOfMaxPossibleFoundObjectsWithoutFilters(): int
    {
        $this->setGenerateOutputWithIterator(false);

        return (int)q_value($this->getSelectSql(true));
    }
538810
private function getMaxDepth()
    {
        $maxDepth = 3;

        $extra = $this->composer->getPackage()->getExtra();

        if (array_key_exists(self::KEY_MAX_DEPTH, $extra)) {
            $maxDepth = $extra[self::KEY_MAX_DEPTH];
            $minDepth = $this->getMinDepth();

            if (is_int($maxDepth) === false     /* Must be an integer */
                || $maxDepth <= $minDepth       /* Larger than the minimum */
                || is_float($maxDepth) === true /* Within the boundaries of integer */
            ) {
                $message = vsprintf(
                    self::MESSAGE_ERROR_WRONG_MAX_DEPTH,
                    array(
                        'key' => self::KEY_MAX_DEPTH,
                        'min' => $minDepth,
                        'given' => var_export($maxDepth, true),
                    )
                );

                throw new \InvalidArgumentException($message);
            }
        }

        return $maxDepth;
    }
847268
public int getMaxIdx() {
        int max = Integer.MIN_VALUE;
        for (int i=0; i<this.top; i++) {
            if (idx[i] > max) {
                max = idx[i];
            }
        }
        return max;
    }