?

@param ? $indiceCourant ?

@return ?
559827
function createJSDivCalls($indiceCourant=0)
    {
        $i=0;
        $js="";
        foreach ($this->ongletsArray as $fieldName => $fieldValue) {
            if ($i==$indiceCourant) {
                $styleDisplay='block';
                $className='OngletOn';

            } else {
                $styleDisplay='none';
                $className='OngletOff';
            }
            $js.="document.getElementById('".
            $this->convertIntituleOnglet($fieldName.$i).$this->idOngletBuilder.
            "').style.display='".$styleDisplay."';";
            $js.="document.getElementById('".
            $this->convertIntituleOnglet($fieldName.$i).
            $this->idOngletBuilder."_onglet').className='".$className."';";
            
            $i++;
        }
        return $js;
    }
298449
public function decreaseIndentLevelUntilIndentTypeIsSpecial(Formatter $formatter)
    {
        $formatter->setFormattedSql(\rtrim($formatter->getFormattedSql(), ' '));
        --$this->indentLvl;

        while ($j = \array_shift($this->indentTypes)) {
            if ('special' !== $j) {
                break;
            }
            --$this->indentLvl;
        }

        return $this;
    }
177512
public function multiply($multiplier, $roundingMode = self::ROUND_HALF_UP, $precision = self::PRECISION_GAAP)
    {
        $this->assertRoundingMode($roundingMode);
        $multiplier = $this->castOperand($multiplier);
        $precision  = $this->castPrecision($precision);

        $amount = $this->amount->mul($multiplier, $this->getInnerPrecision() + 1);

        if (null === $roundingMode) {
            $amount = $amount->round($precision);
        } else {
            $amount = Math::bcround($amount, $precision, $roundingMode);
        }

        return $this->newInstance($amount);
    }
931989
public static function pluriel($singulier, $pluriel, $nb) {
		if ($nb == 0) {
			$result="Aucun " . $singulier;
		} else {
			$result=sprintf(ngettext("%d " . $singulier, "%d " . $pluriel, $nb), $nb);
		}
		return $result;
	}
196705
public function dividedBy($that) : BigRational
    {
        $that = BigRational::of($that);

        $numerator   = $this->numerator->multipliedBy($that->denominator);
        $denominator = $this->denominator->multipliedBy($that->numerator);

        return new BigRational($numerator, $denominator, true);
    }
709123
public function increment($key, $incvalue = 1) {
        $used_key = $this->getUsedKey($key);
        $val = $this->get($key);
        if ($val === null || !is_numeric($val) || !is_numeric($incvalue)) {
            return false;
        }
        if (intval($val) == $val) {
            return $this->redis->incr($used_key, intval($incvalue));
        }
        else { // float values
            $result = intval($val)+intval($incvalue);
            if($this->redis->set($used_key, $result)) {
                return $result;
            }
            return false;
        }
    }
1105165
public function divide($divisor, $roundingMode = self::ROUND_HALF_UP)
    {
        $this->assertOperand($divisor);
        $this->assertRoundingMode($roundingMode);

        if ($divisor == 0) {
            throw new InvalidArgumentException('Division by zero');
        }

        return new self(round($this->amount / $divisor, $this->currency->getPrecision(), $roundingMode), $this->currency);
    }
1268521
public function dividedBy($divValue)
    {
        if ($divValue <= 0) {
            throw new \InvalidArgumentException(
                'A quantity cannot be divided by zero or a negative value');
        }
        $newValue = $this->value / $divValue;

        return new self($this->uom, $newValue);
    }
1259073
public static function one() : BigRational
    {
        static $one;

        if ($one === null) {
            $one = new BigRational(BigInteger::one(), BigInteger::one(), false);
        }

        return $one;
    }
460168
public static function get_Inet( &$inet )
    {
        if( $inet instanceof Inet ) {
            return $inet;
        }
        return !is_null($inet)
            ? new Inet($inet)
            : null
            ;
    }
404587
function tritonics($scale = null) {
		if (is_null($scale)) {
			$scale = $this->scale;
		}
		return $this->findIntervalics(7, $scale);
	}
1167547
public function sort(callable $comparator = null)
    {
        $copy = array_merge($this->value);

        if ($comparator === null) {
            return static::of(sort($copy));
        }

        return static::of(usort($copy, $comparator));
    }
692552
public function invertSignal() : RealNumber
    {
        if ($this->isZero() === true) {
            return new RealNumber(0);
        } elseif ($this->isPositive() === true) {
            return $this->toNegative();
        } else {
            return $this->toPositive();
        }
    }
1150157
public function simplified() : BigRational
    {
        $gcd = $this->numerator->gcd($this->denominator);

        $numerator = $this->numerator->quotient($gcd);
        $denominator = $this->denominator->quotient($gcd);

        return new BigRational($numerator, $denominator, false);
    }
166144
public function indent($level = null)
    {
        $level = $level ?: $this->getLevel();
        array_push($this->indentStack, $level);

        return $level;
    }
299914
public function having($left, $right, $comparator = Cmp::EQ, $conjunction = Cmp::CONJUNCTION_AND)
    {
        $left = ($left instanceof Expression) ? $left : new Expr\Column($left);
        $right = ($right instanceof Expression) ? $right : new Expr\Parameter($right);
        
        return $this->addHavingCondition($left, $right, $comparator, $conjunction);
    }
890098
public function equalJitter(int $attempt) : int
    {
        $half = ($this->exponential($attempt) / 2);

        return (int) floor($half + $this->random(0.0, $half));
    }