Compute Pochhammer's symbol (this)_n.

@param n The number of product terms in the evaluation.
@return Gamma(this+n)/Gamma(this) = this*(this+1)*...*(this+n-1).
168980
public Rational Pochhammer(final BigInteger n) {
        if (n.compareTo(BigInteger.ZERO) < 0) {
            return null;
        } else if (n.compareTo(BigInteger.ZERO) == 0) {
            return Rational.ONE;
        } else {
            /* initialize results with the current value
             */
            Rational res = new Rational(a, b);
            BigInteger i = BigInteger.ONE;
            for (; i.compareTo(n) < 0; i = i.add(BigInteger.ONE)) {
                res = res.multiply(add(i));
            }
            return res;
        }
    }
679393
public Coordinate getCoordinateN(int n) {
		if (isEmpty()) {
			return null;
		}
		if (n >= 0 && n < coordinates.length) {
			return coordinates[n];
		}
		return null;
	}
308668
protected static function c(int $n) : float
    {
        if ($n <= 1) {
            return 1.;
        }
        
        return 2. * (log($n - 1) + M_EULER) - 2. * ($n - 1) / $n;
    }
254957
def toOrdinal(n):
    
    if n == -1:
        retval = _("last")
    elif n == -2:
        retval = _("penultimate")
    elif 1 <= n <= 5:
        retval = _n2w(n, to="ordinal")
    else:
        retval = _n2w(n, to="ordinal_num")
    return retval
435700
public static int count(int[] histogram, int N) {
		int counts = 0;
		for(int i=0;i<N;i++) {
			counts += histogram[i];
		}
		return counts;
	}
266239
public String cardinal(long n) {
        if (n == 0) {
            return "zero";
        }

        StringBuilder buffer = new StringBuilder(20);

        if (n < 0) {
            buffer.append("negative ");
            n = -n;
        }

        n = cardinalGroup(buffer, n, 1000000000000000000L, "quintillion");
        n = cardinalGroup(buffer, n, 1000000000000000L, "quadrillion");
        n = cardinalGroup(buffer, n, 1000000000000L, "trillion");
        n = cardinalGroup(buffer, n, 1000000000L, "billion");
        n = cardinalGroup(buffer, n, 1000000L, "million");
        n = cardinalGroup(buffer, n, 1000L, "thousand");

        cardinal999(buffer, n, false);

        return buffer.toString();
    }
909896
function(n) {
                    n = this._v(n, "n");

                    var toReturn = [];

                    for(var i=0; i<n; i++) {
                        toReturn[i] = this.rexp(1, this.prng())[0];
                    }

                    return toReturn
                }
298999
public int power(int x, int n) {
    assert(x >= 0 && x < getFieldSize());
    if (n == 0) {
      return 1;
    }
    if (x == 0) {
      return 0;
    }
    x = logTable[x] * n;
    if (x < primitivePeriod) {
      return powTable[x];
    }
    x = x % primitivePeriod;
    return powTable[x];
  }
579859
public JTSGeometryExpression<Geometry> geometryN(Integer n) {
        return JTSGeometryExpressions.geometryOperation(SpatialOps.GEOMETRYN, mixin, ConstantImpl.create(n));
    }
1194211
public static double[] pow(double[] x, double n) {
        double[] array = new double[x.length];
        for (int i = 0; i < x.length; i++) {
            array[i] = Math.pow(x[i], n);
        }
        return array;
    }
843168
public AbstractNumber multiply(Bruch operand) {
        BigInteger z = getZaehler().multiply(operand.getZaehler());
        BigInteger n = getNenner().multiply(operand.getNenner());
        return Bruch.of(z, n).kuerzen();
    }
268612
@Nonnegative
  public static long getSmallFactorial (@Nonnegative final int n)
  {
    ValueEnforcer.isBetweenInclusive (n, "n", PREDEFINED_MIN_INDEX, PREDEFINED_MAX_INDEX);
    return PREDEFINED_FACTORIALS_LONG[n];
  }
883201
public static String stringFor(int n)
    {
        switch (n)
        {
            case CUDNN_OP_TENSOR_ADD: return "CUDNN_OP_TENSOR_ADD";
            case CUDNN_OP_TENSOR_MUL: return "CUDNN_OP_TENSOR_MUL";
            case CUDNN_OP_TENSOR_MIN: return "CUDNN_OP_TENSOR_MIN";
            case CUDNN_OP_TENSOR_MAX: return "CUDNN_OP_TENSOR_MAX";
            case CUDNN_OP_TENSOR_SQRT: return "CUDNN_OP_TENSOR_SQRT";
            case CUDNN_OP_TENSOR_NOT: return "CUDNN_OP_TENSOR_NOT";
        }
        return "INVALID cudnnOpTensorOp: "+n;
    }
420440
public static int divisor(int m, int n) {
		while (m % n != 0) {
			int temp = m % n;
			m = n;
			n = temp;
		}
		return n;
	}
663477
function(n) {
            var sum = new Frac(0), l=this.coeffs.length;
            for(var i=0; i<l; i++) {
                var t = this.coeffs[i];
                if(!t.equals(0)) sum = sum.add(t.multiply(new Frac(Math.pow(n, i))));
            }
            return sum;
        }
526203
public function numToAlpha($n)
  {
    for ($r = ""; $n >= 0; $n = intval($n / 26) - 1) {
      $r = chr($n%26 + 0x61) . $r;
    }
    return $r;
  }
756706
def IntGreaterThanOne(n):
    """"""
    try:
        n = int(n)
    except:
        raise ValueError("%s is not an integer" % n)
    if n <= 1:
        raise ValueError("%d is not > 1" % n)
    else:
        return n