Select one unit from 16 containing circle shapes.

@param  integer $rank2 Column index
@access public
@return void
346273
public function row7($rank2)
    {
        // Circle inside other TOP
        if ($rank2 == 0) {
            $this->row4(8);
            $c = new Primitive\Ellipse(self::SIZE / 2, self::SIZE / 4);
            $c->radius(self::SIZE / 4)->color($this->bg());
            $this->add($c);
        }
        // Same as previous bu reversed
        if ($rank2 == 1) {
            $this->row1(1);
            $this->row7(0);
            $this->get(1)->color($this->bg());
            $this->get(2)->color($this->fg());
        }
        // Circle inside other RIGHT
        if ($rank2 == 2) {
            $this->row4(8);
            $c = new Primitive\Ellipse(self::SIZE * (3/4), self::SIZE / 2);
            $c->radius(self::SIZE / 4)->color($this->bg());
            $this->add($c);
        }
        // Same as previous but reversed
        if ($rank2 == 3) {
            $this->row1(1);
            $this->row7(2);
            $this->get(1)->color($this->bg());
            $this->get(2)->color($this->fg());
        }
        // Circle inside other BOTTOM
        if ($rank2 == 4) {
            $this->row4(8);
            $c = new Primitive\Ellipse(self::SIZE /2, self::SIZE * (3/4));
            $c->radius(self::SIZE / 4)->color($this->bg());
            $this->add($c);
        }
        // Same as previous but reversed
        if ($rank2 == 5) {
            $this->row1(1);
            $this->row7(4);
            $this->get(1)->color($this->bg());
            $this->get(2)->color($this->fg());
        }
        // Circle inside other LEFT
        if ($rank2 == 6) {
            $this->row4(8);
            $c = new Primitive\Ellipse(self::SIZE / 4, self::SIZE / 2);
            $c->radius(self::SIZE / 4)->color($this->bg());
            $this->add($c);
        }
        // Same as previous but reversed
        if ($rank2 == 7) {
            $this->row1(1);
            $this->row7(6);
            $this->get(1)->color($this->bg());
            $this->get(2)->color($this->fg());
        }
        if ($rank2 == 8) {
            // Moyen central
            $c = new Primitive\Ellipse(self::SIZE / 2, self::SIZE / 2);
            $c->radius(self::SIZE / 4)->color($this->fg());
            $this->add($c);
            //satellite TL
            $c = new Primitive\Ellipse(self::SIZE / 4, self::SIZE / 4);
            $c->radius(self::SIZE / 4)->color($this->fg());
            $this->add($c);
            //satellite TR
            $c = new Primitive\Ellipse(self::SIZE * (3/4), self::SIZE / 4);
            $c->radius(self::SIZE / 4)->color($this->fg());
            $this->add($c);
            //satellite BR
            $c = new Primitive\Ellipse(self::SIZE * (3/4), self::SIZE * (3/4));
            $c->radius(self::SIZE / 4)->color($this->fg());
            $this->add($c);
            //satellite BL
            $c = new Primitive\Ellipse(self::SIZE / 4, self::SIZE * (3/4));
            $c->radius(self::SIZE / 4)->color($this->fg());
            $this->add($c);
        }
        // same as previous but with central as negative
        if ($rank2 == 9) {
            $this->row7(8);
            $this->add($this->get(0)->color($this->bg()));
        }
        // same as 8, but satellites in negative
        if ($rank2 == 10) {
            $this->row7(8);
            $this->get(1)->color($this->bg());
            $this->get(2)->color($this->bg());
            $this->get(3)->color($this->bg());
            $this->get(4)->color($this->bg());
        }
        // Same as 8 with inside additionnal circles
        if ($rank2 == 11) {
            $this->row7(8);
            // small at center
            $c = new Primitive\Ellipse(self::SIZE / 2, self::SIZE / 2);
            $c->radius(self::SIZE / 8)->color($this->bg());
            $this->add($c);
            //satellite TL
            $c = new Primitive\Ellipse(self::SIZE / 4, self::SIZE / 4);
            $c->radius(self::SIZE / 8)->color($this->bg());
            $this->add($c);
            //satellite TR
            $c = new Primitive\Ellipse(self::SIZE * (3/4), self::SIZE / 4);
            $c->radius(self::SIZE / 8)->color($this->bg());
            $this->add($c);
            //satellite BR
            $c = new Primitive\Ellipse(self::SIZE * (3/4), self::SIZE * (3/4));
            $c->radius(self::SIZE / 8)->color($this->bg());
            $this->add($c);
            //satellite BL
            $c = new Primitive\Ellipse(self::SIZE / 4, self::SIZE * (3/4));
            $c->radius(self::SIZE / 8)->color($this->bg());
            $this->add($c);
        }
        if ($rank2 == 12) {
            $this->row4(8);
            $s = new Primitive\Rectangle();
            $s->point(0, self::SIZE / 2)->size(self::SIZE, self::SIZE / 2);
            $s->color($this->bg());
            $this->add($s);
        }
        if ($rank2 == 13) {
            $this->row4(8);
            $s = new Primitive\Rectangle();
            $s->point(0, 0)->size(self::SIZE, self::SIZE / 2);
            $s->color($this->bg());
            $this->add($s);
        }
        if ($rank2 == 14) {
            $this->row4(8);
            $s = new Primitive\Rectangle();
            $s->point(0, 0)->size(self::SIZE / 2, self::SIZE);
            $s->color($this->bg());
            $this->add($s);
        }
        if ($rank2 == 15) {
            $this->row4(8);
            $s = new Primitive\Rectangle();
            $s->point(self::SIZE / 2, 0)->size(self::SIZE / 2, self::SIZE);
            $s->color($this->bg());
            $this->add($s);
        }
    }
314718
public function setAxisUnit($AxisID, $Unit)
    {
        if (isset($this->Data["Axis"][$AxisID])) {
            $this->Data["Axis"][$AxisID]["Unit"] = $Unit;
        }
    }
1130402
public function setRankingMode($ranker, $rankexpr = '')
    {
        assert($ranker === 0 || $ranker >= 1 && $ranker < SPH_RANK_TOTAL);
        assert(is_string($rankexpr));
        $this->_ranker = $ranker;
        $this->_rankexpr = $rankexpr;

        return $this;
    }
124242
private void hqr2()
    {

        //  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

        int nn = this.n;
        int n = nn - 1;
        int low = 0;
        int high = nn - 1;
        double eps = pow(2.0, -52.0);
        double exshift = 0.0;
        double p = 0, q = 0, r = 0, s = 0, z = 0, t, w, x, y;
        /**
         * Output from complex division
         */
        final double[] cr = new double[2];
        double norm = hqr2GetNormStart(nn, low, high);

        // 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 = abs(H.get(l-1, l-1)) + abs(H.get(l, l));
                if (s == 0.0)
                {
                    s = norm;
                }
                if (abs(H.get(l, l-1)) < eps * s)
                {
                    break;
                }
                l--;
            }

            // Check for convergence
            // One root found

            if (l == n)
            {
                H.increment(n, n, exshift);
                d[n] = H.get(n, n);
                e[n] = 0.0;
                n--;
                iter = 0;
            }
            else if (l == n - 1) // Two roots found
            {
                hqr2FoundTwoRoots(exshift, n, nn, low, high);
                n = n - 2;
                iter = 0;

                // No convergence yet
            }
            else
            {

                // Form shift
                
                x = H.get(n, n);
                y = 0.0;
                w = 0.0;
                if (l < n)
                {
                    y = H.get(n-1, n-1);
                    w = pow(H.get(n, n-1), 2);
                }

                // Wilkinson's original ad hoc shift

                if (iter == 10)
                {
                    exshift += x;
                    RowColumnOps.addDiag(H, low, n+1, -x);
                    s = abs(H.get(n, n-1)) + abs(H.get(n-1, n-2));
                    x = y = 0.75 * s;
                    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 = sqrt(s);
                        if (y < x)
                        {
                            s = -s;
                        }
                        s = x - w / ((y - x) / 2.0 + s);
                        RowColumnOps.addDiag(H, low, n+1, -s);
                        exshift += s;
                        x = y = w = 0.964;
                    }
                }

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

                // Look for two consecutive small sub-diagonal elements

                int m = n - 2;
                while (m >= l)
                {
                    z = H.get(m, m);
                    r = x - z;
                    s = y - z;
                    p = (r * s - w) / H.get(m+1, m) + H.get(m, m+1);
                    q = H.get(m+1, m+1) - z - r - s;
                    r = H.get(m+2, m+1);
                    s = abs(p) + abs(q) + abs(r);
                    p = p / s;
                    q = q / s;
                    r = r / s;
                    if (m == l)
                    {
                        break;
                    }
                    if (abs(H.get(m, m-1)) * (abs(q) + abs(r))
                            < eps * (abs(p) * (abs(H.get(m-1, m-1)) + abs(z)
                            + abs(H.get(m+1, m+1)))))
                    {
                        break;
                    }
                    m--;
                }

                for (int i = m + 2; i <= n; i++)
                {
                    H.set(i, i-2, 0.0);
                    if (i > m + 2)
                    {
                        H.set(i, i-3, 0.0);
                    }
                }

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

                for (int k = m; k <= n - 1; k++)
                {
                    boolean notlast = (k != n - 1);
                    if (k != m)
                    {
                        p = H.get(k, k-1);
                        q = H.get(k+1, k-1);
                        r = (notlast ? H.get(k+2, k-1) : 0.0);
                        x = abs(p) + abs(q) + abs(r);
                        if (x != 0.0)
                        {
                            p = p / x;
                            q = q / x;
                            r = r / x;
                        }
                    }
                    
                    if (x == 0.0)
                        break;
                    
                    s = sqrt(p * p + q * q + r * r);
                    if (p < 0)
                    {
                        s = -s;
                    }
                    if (s != 0)
                    {
                        if (k != m)
                        {
                            H.set(k, k-1, -s*x);
                        }
                        else if (l != m)
                        {
                            H.set(k, k-1, -H.get(k, k-1));
                        }
                        p = p + s;
                        x = p / s;
                        y = q / s;
                        z = r / s;
                        q = q / p;
                        r = r / p;

                        // Row modification
                        rowOpTransform2(H, k, nn - 1, x, k, y, notlast, z, r, q);

                        // Column modification
                        columnOpTransform2(H, 0, min(n, k + 3), x, k, y, notlast, z, r, q);

                        // Accumulate transformations
                        columnOpTransform2(V, low, high, x, k, y, notlast, z, r, q);
                        
                    }  // (s != 0)
                }  // k loop
            }  // check convergence
        }  // while (n >= low)
        
        // Backsubstitute to find vectors of upper triangular form

        if (norm == 0.0)
            return;
        
        backsubtituteFindVectors(nn, z, s, eps, norm, cr);
        
        // Vectors of isolated roots

        for (int i = 0; i < nn; i++)
            if (i < low | i > high)
            {
                for(int j = i; j < nn-1; j++)
                    H.set(i, j, V.get(i, j));
            }
        backtransform(nn, low, high);
    }
1838
protected function shouldSelect(array $columns = ['*'])
    {
        if ($columns === ['*']) {
            $columns = [$this->related->getTable() . '.*'];
        }

        return array_merge($columns, $this->aliasedPivotColumns());
    }
1319687
protected function row4($rank2)
    {
        // Mid sizes TL
        if ($rank2 == 0) {
            $el = new Primitive\Ellipse(self::SIZE / 4, self::SIZE / 4);
            $el->radius(self::SIZE / 4);
            $el->color($this->fg());
            $this->add($el);
        }
        // Mid sizes TR
        if ($rank2 == 1) {
            $el = new Primitive\Ellipse(self::SIZE * (3/4), self::SIZE / 4);
            $el->radius(self::SIZE / 4);
            $el->color($this->fg());
            $this->add($el);
        }
        // Mid sizes BR
        if ($rank2 == 2) {
            $el = new Primitive\Ellipse(self::SIZE * (3/4), self::SIZE * (3/4));
            $el->radius(self::SIZE / 4);
            $el->color($this->fg());
            $this->add($el);
        }
        // Mid sizes BL
        if ($rank2 == 3) {
            $el = new Primitive\Ellipse(self::SIZE / 4, self::SIZE * (3/4));
            $el->radius(self::SIZE / 4);
            $el->color($this->fg());
            $this->add($el);
        }
        if ($rank2 == 4) {
            $el = new Primitive\Ellipse(self::SIZE / 4, self::SIZE / 4);
            $el->radius(self::SIZE / 4);
            $el->color($this->fg());
            $this->add($el);
            $el = new Primitive\Ellipse(self::SIZE / 4, self::SIZE / 4);
            $el->radius(self::SIZE / 8);
            $el->color($this->bg());
            $this->add($el);
        }
        if ($rank2 == 5) {
            $el = new Primitive\Ellipse(self::SIZE * (3/4), self::SIZE / 4);
            $el->radius(self::SIZE / 4);
            $el->color($this->fg());
            $this->add($el);
            $el = new Primitive\Ellipse(self::SIZE * (3/4), self::SIZE / 4);
            $el->radius(self::SIZE / 8);
            $el->color($this->bg());
            $this->add($el);
        }
        if ($rank2 == 6) {
            $el = new Primitive\Ellipse(self::SIZE * (3/4), self::SIZE * (3/4));
            $el->radius(self::SIZE / 4);
            $el->color($this->fg());
            $this->add($el);
            $el = new Primitive\Ellipse(self::SIZE * (3/4), self::SIZE * (3/4));
            $el->radius(self::SIZE / 8);
            $el->color($this->bg());
            $this->add($el);
        }
        if ($rank2 == 7) {
            $el = new Primitive\Ellipse(self::SIZE / 4, self::SIZE * (3/4));
            $el->radius(self::SIZE / 4);
            $el->color($this->fg());
            $this->add($el);
            $el = new Primitive\Ellipse(self::SIZE / 4, self::SIZE * (3/4));
            $el->radius(self::SIZE / 8);
            $el->color($this->bg());
            $this->add($el);
        }
        if ($rank2 == 8) {
            $el = new Primitive\Ellipse(self::SIZE / 2, self::SIZE / 2);
            $el->radius(self::SIZE / 2);
            $el->color($this->fg());
            $this->add($el);
        }
        if ($rank2 == 9) {
            $this->row1(1);
            $el = new Primitive\Ellipse(self::SIZE / 2, self::SIZE / 2);
            $el->radius(self::SIZE / 2);
            $el->color($this->bg());
            $this->add($el);
        }
        if ($rank2 == 10) {
            $this->row4(8);
            $el = new Primitive\Ellipse(self::SIZE / 2, self::SIZE / 2);
            $el->radius(self::SIZE / 4);
            $el->color($this->bg());
            $this->add($el);
        }
        if ($rank2 == 11) {
            $this->row4(9);
            $el = new Primitive\Ellipse(self::SIZE / 2, self::SIZE / 2);
            $el->radius(self::SIZE / 4);
            $el->color($this->fg());
            $this->add($el);
        }
        if ($rank2 == 12) {
            $this->row4(10);
            $el = new Primitive\Ellipse(self::SIZE / 2, self::SIZE / 2);
            $el->radius(self::SIZE / 8);
            $el->color($this->fg());
            $this->add($el);
        }
        if ($rank2 == 13) {
            $this->row4(11);
            $el = new Primitive\Ellipse(self::SIZE / 2, self::SIZE / 2);
            $el->radius(self::SIZE / 8);
            $el->color($this->bg());
            $this->add($el);
        }
        if ($rank2 == 14) {
            $this->row4(0);
            $this->row4(2);
        }
        if ($rank2 == 15) {
            $this->row4(1);
            $this->row4(3);
        }

    }
898713
public function rank()
    {
        $eps = pow(2.0, -52.0);
        $tol = max($this->m, $this->n) * $this->s[0] * $eps;
        $r = 0;
        for ($i = 0; $i < count($this->s); ++$i) {
            if ($this->s[$i] > $tol) {
                ++$r;
            }
        }
        return $r;
    }
1121096
public function setPointShape($shape)
    {
        $allowedValues = array("circle", "triangle", "square", "diamond", "star", "polygon");
        
        if (!in_array($shape, $allowedValues))
        {
            throw new \Exception("Invalid point shape: " . $shape);
        }
        
        $this->m_options['pointShape'] = $shape;
    }
235709
public function select2($config = array())
    {
        $config = new KObjectConfigJson($config);
        $config->append(array(
            'debug' => JFactory::getApplication()->getCfg('debug')
        ));

        return parent::select2($config);
    }
173288
protected function _updateCircle()
    {
        // Sort the circle
        ksort($this->_circle);

        // Now that the hashes are sorted, generate numeric indices into the
        // circle.
        $this->_pointMap = array_keys($this->_circle);
        $this->_pointCount = count($this->_pointMap);
    }
309307
public function select($columns = [])
    {
        $expr = new ColumnExpression($this->sql);

        if ($columns instanceof Closure) {
            $columns($expr);
        } else {
            if (!is_array($columns)) {
                $columns = [$columns];
            }
            $expr->columns($columns);
        }
    }
120573
private int selectCoords(Collection<Point2d[]> ps, Point2d[] coords, IRing macrocycle, IRingSet ringset) {
        assert ps.size() != 0;
        final int[] winding = new int[coords.length];

        MacroScore best = null;
        for (Point2d[] p : ps) {
            final int wind = winding(p, winding);
            MacroScore score = bestScore(macrocycle, ringset, wind, winding);
            if (score.compareTo(best) < 0) {
                best = score;
                System.arraycopy(p, 0, coords, 0, p.length);
            }
        }

        // never null
        return best != null ? best.offset : 0;
    }
1231874
public function sortOrder2(int $sortOrder, bool $descendingFlag = false): void
  {
    $this->sortDirection2 = ($descendingFlag) ? 'desc' : 'asc';
    $this->sortOrder2     = $sortOrder;
  }
572133
public function setRank($rank)
    {
        if (! is_int($rank)) {
            throw new \InvalidArgumentException(
                'Argument 1 must be an int value. Valued passed is of type ' . gettype($rank));
        }
        
        $this->rank = $rank;
    }
282373
protected function setColumnProperties()
    {
        // First of all, add the id (or any other primary key), if not available
        if (! $this->requestedColumns->contains('name', $this->primaryColumn)) {
            $this->selectColumns[] = $this->primaryColumn;
        }

        $this->requestedColumns->each(function ($column) {
            $this->setColumnPropertiesFor($column);
        });
    }
675957
private function setMaxSteps(int $maxSteps): void
    {
        $this->maxSteps = \max(0, $maxSteps);
        $this->stepWidth = $this->maxSteps ? Str::len($this->maxSteps) : 2;
    }
327706
protected function runPaginationCountQuery($columns = ['*'])
    {
        $bindings = $this->from instanceof Subquery ? ['order'] : ['select', 'order'];

        return $this->cloneWithout(['columns', 'orders', 'limit', 'offset'])
                    ->cloneWithoutBindings($bindings)
                    ->setAggregate('count', $this->withoutSelectAliases($columns))
                    ->get()->all();
    }