$NON-NLS-2$ //$NON-NLS-1$ //$NON-NLS-0$
553781
function(data) {
				var name = data.parameters && data.parameters.valueFor('name'); //$NON-NLS-0$
				var findFunction = function(name) {
					var href = require.toUrl("profile/user-profile.html") +"#/users/" + name;
					window.location.href = urlModifier(href);
				};
				if (name) {
					findFunction(name);
				}
			}
827754
function() {

      var a = this['re'];
      var b = this['im'];
      var ret = '';

      if (this['isNaN']()) {
        return 'NaN';
      }

      if (this['isZero']()) {
        return '0';
      }

      if (this['isInfinite']()) {
        return 'Infinity';
      }

      if (a !== 0) {
        ret += a;
      }

      if (b !== 0) {

        if (a !== 0) {
          ret += b < 0 ? ' - ' : ' + ';
        } else if (b < 0) {
          ret += '-';
        }

        b = Math.abs(b);

        if (1 !== b) {
          ret += b;
        }
        ret += 'i';
      }

      if (!ret)
        return '0';

      return ret;
    }
882363
function minus($a) {
    var a = (0, _xvseq._first)($a);
    if (typeof a.neg == "function") return (0, _xvseq.seq)(a.neg());
    return (0, _xvseq.seq)(-a);
}
1116545
function(a, b) {
		if (typeof a === 'number' && typeof b === 'number') {
			return a > b ? 1 : (a < b ? -1 : 0);
		}
		a = asciifold(String(a || ''));
		b = asciifold(String(b || ''));
		if (a > b) return 1;
		if (b > a) return -1;
		return 0;
	}
656487
private double degreeToNumber( String value ) {
        double number = -1;

        String[] valueSplit = value.trim().split(":"); //$NON-NLS-1$
        if (valueSplit.length == 3) {
            // deg:min:sec.ss
            double deg = Double.parseDouble(valueSplit[0]);
            double min = Double.parseDouble(valueSplit[1]);
            double sec = Double.parseDouble(valueSplit[2]);
            number = deg + min / 60.0 + sec / 60.0 / 60.0;
        } else if (valueSplit.length == 2) {
            // deg:min
            double deg = Double.parseDouble(valueSplit[0]);
            double min = Double.parseDouble(valueSplit[1]);
            number = deg + min / 60.0;
        } else if (valueSplit.length == 1) {
            // deg
            number = Double.parseDouble(valueSplit[0]);
        }
        return number;
    }
866529
def dBinaryRochedy (r, D, q, F):
    
    return -r[1]*(r[0]*r[0]+r[1]*r[1]+r[2]*r[2])**-1.5 -q*r[1]*((r[0]-D)*(r[0]-D)+r[1]*r[1]+r[2]*r[2])**-1.5 + F*F*(1+q)*r[1]
1072756
private function tql2(): void
    {
        for ($i = 1; $i < $this->n; ++$i) {
            $this->e[$i - 1] = $this->e[$i];
        }

        $this->e[$this->n - 1] = 0.0;
        $f = 0.0;
        $tst1 = 0.0;
        $eps = 2.0 ** -52.0;

        for ($l = 0; $l < $this->n; ++$l) {
            // Find small subdiagonal element
            $tst1 = max($tst1, abs($this->d[$l]) + abs($this->e[$l]));
            $m = $l;
            while ($m < $this->n) {
                if (abs($this->e[$m]) <= $eps * $tst1) {
                    break;
                }

                ++$m;
            }

            // If m == l, $this->d[l] is an eigenvalue,
            // otherwise, iterate.
            if ($m > $l) {
                do {
                    // Compute implicit shift
                    $g = $this->d[$l];
                    $p = ($this->d[$l + 1] - $g) / (2.0 * $this->e[$l]);
                    $r = hypot($p, 1.0);
                    if ($p < 0) {
                        $r *= -1;
                    }

                    $this->d[$l] = $this->e[$l] / ($p + $r);
                    $this->d[$l + 1] = $this->e[$l] * ($p + $r);
                    $dl1 = $this->d[$l + 1];
                    $h = $g - $this->d[$l];
                    for ($i = $l + 2; $i < $this->n; ++$i) {
                        $this->d[$i] -= $h;
                    }

                    $f += $h;
                    // Implicit QL transformation.
                    $p = $this->d[$m];
                    $c = 1.0;
                    $c2 = $c3 = $c;
                    $el1 = $this->e[$l + 1];
                    $s = $s2 = 0.0;
                    for ($i = $m - 1; $i >= $l; --$i) {
                        $c3 = $c2;
                        $c2 = $c;
                        $s2 = $s;
                        $g = $c * $this->e[$i];
                        $h = $c * $p;
                        $r = hypot($p, $this->e[$i]);
                        $this->e[$i + 1] = $s * $r;
                        $s = $this->e[$i] / $r;
                        $c = $p / $r;
                        $p = $c * $this->d[$i] - $s * $g;
                        $this->d[$i + 1] = $h + $s * ($c * $g + $s * $this->d[$i]);
                        // Accumulate transformation.
                        for ($k = 0; $k < $this->n; ++$k) {
                            $h = $this->V[$k][$i + 1];
                            $this->V[$k][$i + 1] = $s * $this->V[$k][$i] + $c * $h;
                            $this->V[$k][$i] = $c * $this->V[$k][$i] - $s * $h;
                        }
                    }

                    $p = -$s * $s2 * $c3 * $el1 * $this->e[$l] / $dl1;
                    $this->e[$l] = $s * $p;
                    $this->d[$l] = $c * $p;
                    // Check for convergence.
                } while (abs($this->e[$l]) > $eps * $tst1);
            }

            $this->d[$l] += $f;
            $this->e[$l] = 0.0;
        }

        // Sort eigenvalues and corresponding vectors.
        for ($i = 0; $i < $this->n - 1; ++$i) {
            $k = $i;
            $p = $this->d[$i];
            for ($j = $i + 1; $j < $this->n; ++$j) {
                if ($this->d[$j] < $p) {
                    $k = $j;
                    $p = $this->d[$j];
                }
            }

            if ($k != $i) {
                $this->d[$k] = $this->d[$i];
                $this->d[$i] = $p;
                for ($j = 0; $j < $this->n; ++$j) {
                    $p = $this->V[$j][$i];
                    $this->V[$j][$i] = $this->V[$j][$k];
                    $this->V[$j][$k] = $p;
                }
            }
        }
    }
1149861
def _JRStaeckelIntegrandSquared(u,E,Lz,I3U,delta,u0,sinh2u0,v0,sin2v0,
                                potu0v0,pot):
    #potu0v0= potentialStaeckel(u0,v0,pot,delta)
    """"""
    sinh2u= nu.sinh(u)**2.
    dU= (sinh2u+sin2v0)*potentialStaeckel(u,v0,
                                          pot,delta)\
        -(sinh2u0+sin2v0)*potu0v0
    return E*sinh2u-I3U-dU-Lz**2./2./delta**2./sinh2u
847218
function(signal1, signal2, options){
    options = options || {};
    options.epsilon = options.epsilon || 1E-08;
    var sig1 = Signal(signal1);
    var sig2 = Signal(signal2);
    if(signal1.length != signal2.length) return false;
    var diffSQ = _.reduce(_.range(signal1.length), function(d,idx){
      var diff = (sig1[idx].value-sig2[idx].value);
        return d + diff * diff;
    },0);
    return diffSQ/signal1.length < options.epsilon;
  }
1100816
function(n)
	{
		return !isNaN(parseFloat(n)) && isFinite(n) && (typeof(n) != 'string' || n.toLowerCase().indexOf('0x') < 0);
	}
773147
public function hsl2rgb($h, $s, $l)
	{
		if ($s == 0) {
			$r = $l * 255;
			$g = $l * 255;
			$b = $l * 255;
		} else {
			if ($l < 0.5) {
				$tmp = $l * (1 + $s);
			} else {
				$tmp = ($l + $s) - ($s * $l);
			}
			$tmp2 = 2 * $l - $tmp;
			$r = round(255 * $this->hue2rgb($tmp2, $tmp, $h + (1 / 3)));
			$g = round(255 * $this->hue2rgb($tmp2, $tmp, $h));
			$b = round(255 * $this->hue2rgb($tmp2, $tmp, $h - (1 / 3)));
		}

		return [$r, $g, $b];
	}
1057102
def is_negative(pattern, flags):
    """"""

    if flags & MINUSNEGATE:
        return flags & NEGATE and pattern[0:1] in MINUS_NEGATIVE_SYM
    else:
        return flags & NEGATE and pattern[0:1] in NEGATIVE_SYM
340829
function lchoose(n, k) {
      k = Math.round(k);
      if (utils.hasNaN(n, k)) { return NaN; }
      if (k < 0) { return -Infinity; }
      if (k === 0) { return 0; }
      if (k === 1) { return Math.log(Math.abs(n)); }
      if (n < 0) { return lchoose(-n + k - 1, k); }
      if (n === Math.round(n)) {
         if (n < k) { return -Infinity; }
         if (n - k < 2) { return lchoose(n, n - k); }

         return lfastchoose(n, k);
      }
      if (n < k - 1) { return lfastchoose2(n, k); }

      return lfastchoose(n, k);
   }
136796
function liesOnSegment(s, p) {
  if (nearlyEquals(s.p1.x, s.p2.x)) return isBetween(p.y, s.p1.y, s.p2.y);
  return isBetween(p.x, s.p1.x, s.p2.x);
}
1008607
function(d2) {

      var w = this['w'];
      var x = this['x'];
      var y = this['y'];
      var z = this['z'];

      var n = w * w + x * x + y * y + z * z;
      var s = n === 0 ? 0 : 2 / n;
      var wx = s * w * x, wy = s * w * y, wz = s * w * z;
      var xx = s * x * x, xy = s * x * y, xz = s * x * z;
      var yy = s * y * y, yz = s * y * z, zz = s * z * z;

      if (d2) {
        return [
          [1 - (yy + zz), xy - wz, xz + wy],
          [xy + wz, 1 - (xx + zz), yz - wx],
          [xz - wy, yz + wx, 1 - (xx + yy)]];
      }

      return [
        1 - (yy + zz), xy - wz, xz + wy,
        xy + wz, 1 - (xx + zz), yz - wx,
        xz - wy, yz + wx, 1 - (xx + yy)];
    }
1029768
private void _nonsymetricHqr2 ()
  {
    // This is derived from the Algol procedure hqr2,
    // by Martin and Wilkinson, Handbook for Auto. Comp.,
    // Vol.ii-Linear Algebra, and the corresponding
    // Fortran subroutine in EISPACK.

    // Initialize

    final int nn = m_nDim;
    int n = nn - 1;
    final int low = 0;
    final int high = nn - 1;
    double exshift = 0;
    double p = 0;
    double q = 0;
    double r = 0;
    double s = 0;
    double z = 0;
    double t;
    double w;
    double x;
    double y;

    // Store roots isolated by balanc and compute matrix norm
    double norm = 0.0;
    for (int i = 0; i < nn; i++)
    {
      if (i < low || i > high)
      {
        m_aEVd[i] = m_aHessenBerg[i][i];
        m_aEVe[i] = 0.0;
      }
      for (int j = Math.max (i - 1, 0); j < nn; j++)
      {
        norm += MathHelper.abs (m_aHessenBerg[i][j]);
      }
    }

    // Outer loop over eigenvalue index
    int iter = 0;
    while (n >= low)
    {
      // Look for single small sub-diagonal element
      int l = n;
      while (l > low)
      {
        s = MathHelper.abs (m_aHessenBerg[l - 1][l - 1]) + MathHelper.abs (m_aHessenBerg[l][l]);
        if (s == 0.0)
          s = norm;
        if (MathHelper.abs (m_aHessenBerg[l][l - 1]) < EPSILON * s)
          break;
        l--;
      }

      // Check for convergence
      // One root found
      if (l == n)
      {
        m_aHessenBerg[n][n] = m_aHessenBerg[n][n] + exshift;
        m_aEVd[n] = m_aHessenBerg[n][n];
        m_aEVe[n] = 0.0;
        n--;
        iter = 0;
        // Two roots found
      }
      else
        if (l == n - 1)
        {
          w = m_aHessenBerg[n][n - 1] * m_aHessenBerg[n - 1][n];
          p = (m_aHessenBerg[n - 1][n - 1] - m_aHessenBerg[n][n]) / 2.0;
          q = p * p + w;
          z = Math.sqrt (MathHelper.abs (q));
          m_aHessenBerg[n][n] = m_aHessenBerg[n][n] + exshift;
          m_aHessenBerg[n - 1][n - 1] = m_aHessenBerg[n - 1][n - 1] + exshift;
          x = m_aHessenBerg[n][n];

          // Real pair

          if (q >= 0)
          {
            if (p >= 0)
              z = p + z;
            else
              z = p - z;
            m_aEVd[n - 1] = x + z;
            m_aEVd[n] = m_aEVd[n - 1];
            if (z != 0.0)
              m_aEVd[n] = x - w / z;
            m_aEVe[n - 1] = 0.0;
            m_aEVe[n] = 0.0;
            x = m_aHessenBerg[n][n - 1];
            s = MathHelper.abs (x) + MathHelper.abs (z);
            p = x / s;
            q = z / s;
            r = Math.sqrt (p * p + q * q);
            p /= r;
            q /= r;

            // Row modification
            for (int j = n - 1; j < nn; j++)
            {
              z = m_aHessenBerg[n - 1][j];
              m_aHessenBerg[n - 1][j] = q * z + p * m_aHessenBerg[n][j];
              m_aHessenBerg[n][j] = q * m_aHessenBerg[n][j] - p * z;
            }

            // Column modification
            for (int i = 0; i <= n; i++)
            {
              z = m_aHessenBerg[i][n - 1];
              m_aHessenBerg[i][n - 1] = q * z + p * m_aHessenBerg[i][n];
              m_aHessenBerg[i][n] = q * m_aHessenBerg[i][n] - p * z;
            }

            // Accumulate transformations
            for (int i = low; i <= high; i++)
            {
              z = m_aEigenVector[i][n - 1];
              m_aEigenVector[i][n - 1] = q * z + p * m_aEigenVector[i][n];
              m_aEigenVector[i][n] = q * m_aEigenVector[i][n] - p * z;
            }

            // Complex pair
          }
          else
          {
            m_aEVd[n - 1] = x + p;
            m_aEVd[n] = x + p;
            m_aEVe[n - 1] = z;
            m_aEVe[n] = -z;
          }
          n -= 2;
          iter = 0;

          // No convergence yet
        }
        else
        {
          // Form shift
          x = m_aHessenBerg[n][n];
          y = 0.0;
          w = 0.0;
          if (l < n)
          {
            y = m_aHessenBerg[n - 1][n - 1];
            w = m_aHessenBerg[n][n - 1] * m_aHessenBerg[n - 1][n];
          }

          // Wilkinson's original ad hoc shift
          if (iter == 10)
          {
            exshift += x;
            for (int i = low; i <= n; i++)
            {
              m_aHessenBerg[i][i] -= x;
            }
            s = MathHelper.abs (m_aHessenBerg[n][n - 1]) + MathHelper.abs (m_aHessenBerg[n - 1][n - 2]);
            x = 0.75 * s;
            y = x;
            w = -0.4375 * s * s;
          }

          // MATLAB's new ad hoc shift
          if (iter == 30)
          {
            s = (y - x) / 2.0;
            s = s * s + w;
            if (s > 0)
            {
              s = Math.sqrt (s);
              if (y < x)
                s = -s;
              s = x - w / ((y - x) / 2.0 + s);
              for (int i = low; i <= n; i++)
              {
                m_aHessenBerg[i][i] -= s;
              }
              exshift += s;
              x = 0.964;
              y = x;
              w = x;
            }
          }

          iter++; // (Could check iteration count here.)

          // Look for two consecutive small sub-diagonal elements
          int m = n - 2;
          while (m >= l)
          {
            z = m_aHessenBerg[m][m];
            r = x - z;
            s = y - z;
            p = (r * s - w) / m_aHessenBerg[m + 1][m] + m_aHessenBerg[m][m + 1];
            q = m_aHessenBerg[m + 1][m + 1] - z - r - s;
            r = m_aHessenBerg[m + 2][m + 1];
            s = MathHelper.abs (p) + MathHelper.abs (q) + MathHelper.abs (r);
            p /= s;
            q /= s;
            r /= s;
            if (m == l)
              break;
            if (MathHelper.abs (m_aHessenBerg[m][m - 1]) *
                (MathHelper.abs (q) + MathHelper.abs (r)) < EPSILON *
                                                            (MathHelper.abs (p) *
                                                             (MathHelper.abs (m_aHessenBerg[m - 1][m - 1]) +
                                                              MathHelper.abs (z) +
                                                              MathHelper.abs (m_aHessenBerg[m + 1][m + 1]))))
            {
              break;
            }
            m--;
          }

          for (int i = m + 2; i <= n; i++)
          {
            m_aHessenBerg[i][i - 2] = 0.0;
            if (i > m + 2)
            {
              m_aHessenBerg[i][i - 3] = 0.0;
            }
          }

          // Double QR step involving rows l:n and columns m:n

          for (int k = m; k <= n - 1; k++)
          {
            final boolean notlast = (k != n - 1);
            if (k != m)
            {
              p = m_aHessenBerg[k][k - 1];
              q = m_aHessenBerg[k + 1][k - 1];
              r = (notlast ? m_aHessenBerg[k + 2][k - 1] : 0.0);
              x = MathHelper.abs (p) + MathHelper.abs (q) + MathHelper.abs (r);
              if (x == 0.0)
              {
                continue;
              }
              p /= x;
              q /= x;
              r /= x;
            }

            s = Math.sqrt (p * p + q * q + r * r);
            if (p < 0)
            {
              s = -s;
            }
            if (s != 0)
            {
              if (k != m)
              {
                m_aHessenBerg[k][k - 1] = -s * x;
              }
              else
                if (l != m)
                {
                  m_aHessenBerg[k][k - 1] = -m_aHessenBerg[k][k - 1];
                }
              p += s;
              x = p / s;
              y = q / s;
              z = r / s;
              q /= p;
              r /= p;

              // Row modification

              for (int j = k; j < nn; j++)
              {
                p = m_aHessenBerg[k][j] + q * m_aHessenBerg[k + 1][j];
                if (notlast)
                {
                  p += r * m_aHessenBerg[k + 2][j];
                  m_aHessenBerg[k + 2][j] = m_aHessenBerg[k + 2][j] - p * z;
                }
                m_aHessenBerg[k][j] = m_aHessenBerg[k][j] - p * x;
                m_aHessenBerg[k + 1][j] = m_aHessenBerg[k + 1][j] - p * y;
              }

              // Column modification

              for (int i = 0; i <= Math.min (n, k + 3); i++)
              {
                p = x * m_aHessenBerg[i][k] + y * m_aHessenBerg[i][k + 1];
                if (notlast)
                {
                  p += z * m_aHessenBerg[i][k + 2];
                  m_aHessenBerg[i][k + 2] = m_aHessenBerg[i][k + 2] - p * r;
                }
                m_aHessenBerg[i][k] = m_aHessenBerg[i][k] - p;
                m_aHessenBerg[i][k + 1] = m_aHessenBerg[i][k + 1] - p * q;
              }

              // Accumulate transformations

              for (int i = low; i <= high; i++)
              {
                p = x * m_aEigenVector[i][k] + y * m_aEigenVector[i][k + 1];
                if (notlast)
                {
                  p += z * m_aEigenVector[i][k + 2];
                  m_aEigenVector[i][k + 2] = m_aEigenVector[i][k + 2] - p * r;
                }
                m_aEigenVector[i][k] = m_aEigenVector[i][k] - p;
                m_aEigenVector[i][k + 1] = m_aEigenVector[i][k + 1] - p * q;
              }
            } // (s != 0)
          } // k loop
        } // check convergence
    } // while (n >= low)

    // Backsubstitute to find vectors of upper triangular form

    if (norm == 0.0)
    {
      return;
    }

    for (n = nn - 1; n >= 0; n--)
    {
      p = m_aEVd[n];
      q = m_aEVe[n];

      // Real vector

      if (q == 0)
      {
        int l = n;
        m_aHessenBerg[n][n] = 1.0;
        for (int i = n - 1; i >= 0; i--)
        {
          w = m_aHessenBerg[i][i] - p;
          r = 0.0;
          for (int j = l; j <= n; j++)
          {
            r += m_aHessenBerg[i][j] * m_aHessenBerg[j][n];
          }
          if (m_aEVe[i] < 0.0)
          {
            z = w;
            s = r;
          }
          else
          {
            l = i;
            if (m_aEVe[i] == 0.0)
            {
              if (w != 0.0)
              {
                m_aHessenBerg[i][n] = -r / w;
              }
              else
              {
                m_aHessenBerg[i][n] = -r / (EPSILON * norm);
              }

              // Solve real equations

            }
            else
            {
              x = m_aHessenBerg[i][i + 1];
              y = m_aHessenBerg[i + 1][i];
              q = (m_aEVd[i] - p) * (m_aEVd[i] - p) + m_aEVe[i] * m_aEVe[i];
              t = (x * s - z * r) / q;
              m_aHessenBerg[i][n] = t;
              if (MathHelper.abs (x) > MathHelper.abs (z))
              {
                m_aHessenBerg[i + 1][n] = (-r - w * t) / x;
              }
              else
              {
                m_aHessenBerg[i + 1][n] = (-s - y * t) / z;
              }
            }

            // Overflow control

            t = MathHelper.abs (m_aHessenBerg[i][n]);
            if ((EPSILON * t) * t > 1)
            {
              for (int j = i; j <= n; j++)
              {
                m_aHessenBerg[j][n] = m_aHessenBerg[j][n] / t;
              }
            }
          }
        }

        // Complex vector

      }
      else
        if (q < 0)
        {
          int l = n - 1;

          // Last vector component imaginary so matrix is triangular

          if (MathHelper.abs (m_aHessenBerg[n][n - 1]) > MathHelper.abs (m_aHessenBerg[n - 1][n]))
          {
            m_aHessenBerg[n - 1][n - 1] = q / m_aHessenBerg[n][n - 1];
            m_aHessenBerg[n - 1][n] = -(m_aHessenBerg[n][n] - p) / m_aHessenBerg[n][n - 1];
          }
          else
          {
            _cdiv (0.0, -m_aHessenBerg[n - 1][n], m_aHessenBerg[n - 1][n - 1] - p, q);
            m_aHessenBerg[n - 1][n - 1] = m_dCdivr;
            m_aHessenBerg[n - 1][n] = m_dCdivi;
          }
          m_aHessenBerg[n][n - 1] = 0.0;
          m_aHessenBerg[n][n] = 1.0;
          for (int i = n - 2; i >= 0; i--)
          {
            double ra = 0.0;
            double sa = 0.0;
            double vr;
            double vi;
            for (int j = l; j <= n; j++)
            {
              ra += m_aHessenBerg[i][j] * m_aHessenBerg[j][n - 1];
              sa += m_aHessenBerg[i][j] * m_aHessenBerg[j][n];
            }
            w = m_aHessenBerg[i][i] - p;

            if (m_aEVe[i] < 0.0)
            {
              z = w;
              r = ra;
              s = sa;
            }
            else
            {
              l = i;
              if (m_aEVe[i] == 0)
              {
                _cdiv (-ra, -sa, w, q);
                m_aHessenBerg[i][n - 1] = m_dCdivr;
                m_aHessenBerg[i][n] = m_dCdivi;
              }
              else
              {

                // Solve complex equations

                x = m_aHessenBerg[i][i + 1];
                y = m_aHessenBerg[i + 1][i];
                vr = (m_aEVd[i] - p) * (m_aEVd[i] - p) + m_aEVe[i] * m_aEVe[i] - q * q;
                vi = (m_aEVd[i] - p) * 2.0 * q;
                if (vr == 0.0 && vi == 0.0)
                {
                  vr = EPSILON *
                       norm *
                       (MathHelper.abs (w) +
                        MathHelper.abs (q) +
                        MathHelper.abs (x) +
                        MathHelper.abs (y) +
                        MathHelper.abs (z));
                }
                _cdiv (x * r - z * ra + q * sa, x * s - z * sa - q * ra, vr, vi);
                m_aHessenBerg[i][n - 1] = m_dCdivr;
                m_aHessenBerg[i][n] = m_dCdivi;
                if (MathHelper.abs (x) > (MathHelper.abs (z) + MathHelper.abs (q)))
                {
                  m_aHessenBerg[i + 1][n - 1] = (-ra - w * m_aHessenBerg[i][n - 1] + q * m_aHessenBerg[i][n]) / x;
                  m_aHessenBerg[i + 1][n] = (-sa - w * m_aHessenBerg[i][n] - q * m_aHessenBerg[i][n - 1]) / x;
                }
                else
                {
                  _cdiv (-r - y * m_aHessenBerg[i][n - 1], -s - y * m_aHessenBerg[i][n], z, q);
                  m_aHessenBerg[i + 1][n - 1] = m_dCdivr;
                  m_aHessenBerg[i + 1][n] = m_dCdivi;
                }
              }

              // Overflow control

              t = Math.max (MathHelper.abs (m_aHessenBerg[i][n - 1]), MathHelper.abs (m_aHessenBerg[i][n]));
              if ((EPSILON * t) * t > 1)
              {
                for (int j = i; j <= n; j++)
                {
                  m_aHessenBerg[j][n - 1] = m_aHessenBerg[j][n - 1] / t;
                  m_aHessenBerg[j][n] = m_aHessenBerg[j][n] / t;
                }
              }
            }
          }
        }
    }

    // Vectors of isolated roots

    for (int i = 0; i < nn; i++)
    {
      if (i < low || i > high)
      {
        for (int j = i; j < nn; j++)
        {
          m_aEigenVector[i][j] = m_aHessenBerg[i][j];
        }
      }
    }

    // Back transformation to get eigenvectors of original matrix

    for (int j = nn - 1; j >= low; j--)
    {
      for (int i = low; i <= high; i++)
      {
        z = 0.0;
        for (int k = low; k <= Math.min (j, high); k++)
        {
          z += m_aEigenVector[i][k] * m_aHessenBerg[k][j];
        }
        m_aEigenVector[i][j] = z;
      }
    }
  }
1164955
def ccor2(alt, r, h1, zh, h2):
    '''

 '''
    e1 = (alt - zh) / h1;
    e2 = (alt - zh) / h2;
    if ((e1 > 70.0) or (e2 > 70)): # pragma: no cover
        return 1.0 # exp(0)
    if ((e1 < -70) and (e2 < -70)): # pragma: no cover
        return exp(r)
    ex1 = exp(e1);
    ex2 = exp(e2);
    ccor2v = r / (1.0 + 0.5 * (ex1 + ex2));
    return exp(ccor2v);