function Generate($level)
 {
     if ($level <= 3) {
         $num1 = pow(2, rand(2, 3));
         $num2 = pow(2, rand(4, 5));
     } elseif ($level <= 6) {
         $num1 = pow(2, rand(1, 3)) * pow(3, rand(0, 1));
         $num2 = pow(2, rand(1, 4)) * pow(3, rand(2, 3));
     } else {
         $num1 = pow(2, rand(1, 3)) * pow(3, rand(0, 3)) * pow(5, rand(0, 1));
         $num2 = pow(2, rand(1, 4)) * pow(3, rand(0, 3)) * pow(5, rand(2, 3));
     }
     $gcd = gcd($num1, $num2);
     $num3 = rand(1, 2) == 1 ? $gcd : $gcd / 2;
     // // Original exercise
     // $num1 = 48;
     // $num2 = 120;
     // $num3 = 12;
     // $gcd = gcd($num1, $num2);
     $correct = $num3 == $gcd ? 0 : 1;
     $options = ['Igaz', 'Hamis'];
     $solution = $options[$correct];
     $question = 'Adja meg az alábbi állítás logikai értékét (igaz vagy hamis)!<br />' . The($num1, TRUE) . ' $' . $num1 . '$ és ' . The($num2) . ' $' . $num2 . '$ legnagyobb közös osztója ' . The($num3) . ' $' . $num3 . '$.';
     $page[] = '<div class="alert alert-info"><strong>Közös osztó:</strong> az a szám, amivel mind a két szám osztható.</div>';
     $page[] = '<div class="alert alert-info"><strong>Legnagyobb közös osztó:</strong> a közös osztók közül a legnagyobb. Az $a$ és $b$ számok legnagyobb közös osztóját $(a;b)$-vel jelöljük.</div>';
     $page[] = 'A legnagyobb közös osztó kiszámításához először írjuk fel mindkét szám prímtényezős felbontását!';
     $hints[] = $page;
     $hints[][] = 'Az első szám prímtényezős felbontása: $' . $num1 . '=' . implode('\\cdot', $this->CanonicForm($num1)) . '$, ugyanis:' . $this->Factorization($num1);
     $hints[][] = 'A második szám prímtényezős felbontása: $' . $num2 . '=' . implode('\\cdot', $this->CanonicForm($num2)) . '$, ugyanis:' . $this->Factorization($num2);
     $page = [];
     $page[] = 'Most gyűjtsünk össze a közös prímtényezőket (ha mindkét számban előfordul, akkor a kisebb kitevőt nézzük): $$(' . $num1 . ';' . $num2 . ')=' . implode('\\cdot', $this->CanonicForm($gcd)) . '=' . $gcd . '$$';
     $page[] = 'Mivel a legnagyobb közös osztó ' . ($gcd == $num3 ? 'megegyezik' : 'nem egyezik meg') . ' ' . The($num3) . ' $' . $num3 . '$-' . With($num3) . ', ezért az állítás <span class="label label-success">' . strtolower($solution) . '</span>.';
     $hints[] = $page;
     return array('question' => $question, 'correct' => $correct, 'solution' => $solution, 'options' => $options, 'hints' => $hints);
 }

function fract_label($v)
{
    # Add leading sign and make positive:
    if ($v < 0) {
        $result = '-';
        $v *= -1;
    } elseif ($v == 0) {
        $result = '0';
    } else {
        $result = '';
    }
    # Process whole number part.
    # Prepare for space between number and fraction.
    if ($v >= 1) {
        $whole = (int) $v;
        $v -= $whole;
        $result .= $whole;
        $space_between = ' ';
    } else {
        $space_between = '';
    }
    # Process fractional part:
    if ($v > 0) {
        $p64 = (int) round($v * 64);
        $factor = gcd($p64, 64);
        $numerator = $p64 / $factor;
        $denominator = 64 / $factor;
        $result .= $space_between . $numerator . '/' . $denominator;
    }
    return $result;
}

function gcd($a, $b)
{
    if ($b == 0) {
        return $a;
    }
    return gcd($b, $a % $b);
}

function gcd($a, $b)
{
    if (!b) {
        return a;
    } else {
        return gcd(b, a % b);
    }
}

function gcd($a, $b)
{
    if ($a == 0) {
        return $b;
    } else {
        return gcd($b, $a % $b);
    }
}

function lcd($a, $b)
{
    if ($a < $b) {
        $c = $a;
        $a = $b;
        $b = $c;
    }
    return $a * $b / gcd($a, $b);
}

function ritmo($durações)
{
    $tempos = 0;
    $unidade = max($durações);
    foreach ($durações as $duração) {
        $tempos += $unidade / $duração;
    }
    $gcd = gcd($tempos, $unidade);
    $tempos /= $gcd;
    $unidade /= $gcd;
    return "{$tempos}/{$unidade}";
}

    function Generate($level)
    {
        $m = pow(-1, rand(1, 2)) * rand(1, 2);
        $b = rand(-5, 5);
        $A[0] = pow(-1, rand(1, 2)) * rand(1, 10);
        // Ax != 0
        $A[1] = $A[0] * $m + $b;
        $B[0] = -$A[0];
        $B[1] = $B[0] * $m + $b;
        // // Original exercise
        // $A = [-3,-1];
        // $B = [3,7];
        // $m = ($A[1]-$B[1])/($A[0]-$B[0]);
        // $b = $A[1] - $A[0]*$m;
        // print_r('m='.$m.', b='.$b.'<br />');
        // print_r('A('.$A[0].';'.$A[1].'), B('.$B[0].';'.$B[1].')	<br />');
        $mfrac['nom'] = ($B[1] - $A[1]) / gcd($B[1] - $A[1], $B[0] - $A[0]);
        $mfrac['denum'] = ($B[0] - $A[0]) / gcd($B[1] - $A[1], $B[0] - $A[0]);
        $question = 'Írja fel a hozzárendelési utasítását annak a lineáris függvénynek, mely $' . ($A[0] < 0 ? '(' . $A[0] . ')' : $A[0]) . '$-' . To($A[0]) . ' $' . ($A[1] < 0 ? '(' . $A[1] . ')' : $A[1]) . '$-' . Dativ($A[1]) . ' és $' . ($B[0] < 0 ? '(' . $B[0] . ')' : $B[0]) . '$-' . To($B[0]) . ' $' . ($B[1] < 0 ? '(' . $B[1] . ')' : $B[1]) . '$-' . Dativ($B[1]) . ' rendel! (A hozzárendelési utasítást $x\\mapsto mx+b$ alakban adja meg!)';
        $page[] = 'A hozzárendelés egy $y=mx+b$ alakú lineáris függvény lesz.';
        $page[] = 'A függvény $' . ($A[0] < 0 ? '(' . $A[0] . ')' : $A[0]) . '$-' . To($A[0]) . ' $' . ($A[1] < 0 ? '(' . $A[1] . ')' : $A[1]) . '$-' . Dativ($A[1]) . ' rendel, azaz:$$' . $A[1] . '=' . $A[0] . '\\cdot m+b$$';
        $page[] = 'Továbbá azt is tudjuk, hogy $' . ($B[0] < 0 ? '(' . $B[0] . ')' : $B[0]) . '$-' . To($B[0]) . ' $' . ($B[1] < 0 ? '(' . $B[1] . ')' : $B[1]) . '$-' . Dativ($B[1]) . ' rendel, azaz:$$' . $B[1] . '=' . $B[0] . '\\cdot m+b$$';
        $hints[] = $page;
        $page = [];
        $page[] = '$$\\begin{eqnarray}
			I.\\quad& ' . $A[1] . '&=&' . $A[0] . '\\cdot m+b\\\\
			II.\\quad& ' . $B[1] . '&=&' . $B[0] . '\\cdot m+b
		\\end{eqnarray}$$
			Vonjuk ki az első egyenletből a másodikat! Ekkor a $b$-s tagok kiesnek:$$\\begin{eqnarray}
			' . $A[1] . (-$B[1] < 0 ? '' : '+') . strval(-$B[1]) . '&=&(' . $A[0] . (-$B[0] < 0 ? '' : '+') . strval(-$B[0]) . ')\\cdot m+b-b\\\\
			' . strval($A[1] - $B[1]) . '&=&' . strval($A[0] - $B[0]) . '\\cdot m\\\\
			\\frac{' . strval($A[1] - $B[1]) . '}{' . strval($A[0] - $B[0]) . '}&=&m\\\\
		\\end{eqnarray}$$';
        $page[] = 'Tehát az $m$ értéke <span class="label label-success">$' . (round($m) == $m ? $m : '\\frac{' . $mfrac['nom'] . '}{' . $mfrac['denum'] . '}') . '$</span>.';
        $hints[] = $page;
        $page = [];
        $page[] = '$$\\begin{eqnarray}
			I.\\quad& ' . $A[1] . '&=&' . $A[0] . '\\cdot m+b\\\\
			II.\\quad& ' . $B[1] . '&=&' . $B[0] . '\\cdot m+b
		\\end{eqnarray}$$
		Most adjuk össze a két egyenletet! Ekkor az $m$-es tagok esnek ki:$$\\begin{eqnarray}
			' . $A[1] . ($B[1] < 0 ? '' : '+') . $B[1] . '&=&(' . $A[0] . ($B[0] < 0 ? '' : '+') . $B[0] . ')\\cdot m+b+b\\\\
			' . strval($A[1] + $B[1]) . '&=&2\\cdot b\\\\
			\\frac{' . strval($A[1] + $B[1]) . '}{2}&=&b\\\\
		\\end{eqnarray}$$';
        $page[] = 'Tehát a $b$ értéke <span class="label label-success">$' . $b . '$</span>.';
        $hints[] = $page;
        $correct = [round1($m), $b];
        $solution = '$m=' . round2($m) . '\\quad b=' . $b . '$';
        return array('question' => $question, 'correct' => $correct, 'type' => 'array', 'solution' => $solution, 'hints' => $hints, 'labels' => ['$m$', '$b$']);
    }

function gcd($m, $n)
{
    if ($m < $n) {
        return -1;
    }
    if ($n == 0) {
        return $m;
    }
    $m = $m % $n;
    if ($m == 0) {
        return $n;
    }
    return gcd($n, $m);
}

function gcd($x, $y)
{
    if ($x >= $y) {
        $a = $x;
        $b = $y;
    } else {
        $a = $y;
        $b = $x;
    }
    if ($b <= 0) {
        if ($b >= 0) {
            return $a + 0;
        }
    }
    return gcd($b + 0, $a - $b);
}

/**
 * Weighted round-robin
 *
 * Adapted from LVS Weighted round-robin implementation
 * (@see http://kb.linuxvirtualserver.org/wiki/Weighted_Round-Robin_Scheduling)
 *
 * @param  array    $S  weights
 * @param  integer &$i  current position
 * @param  integer &$cw current weight
 * @return integer
 */
function wrr($S, &$i = -1, &$cw = 0)
{
    if (!($n = count($S))) {
        return null;
    }
    while (true) {
        $i = ($i + 1) % $n;
        if ($i == 0) {
            $cw = $cw - gcd($S);
            if ($cw <= 0) {
                $cw = max($S);
                if ($cw == 0) {
                    return null;
                }
            }
        }
        if ($S[$i] >= $cw) {
            return $i;
        }
    }
}

function cryptorsakeys($p, $q)
{
    $n = $p * $q;
    $phi = ($p - 1) * ($q - 1);
    $e = 3;
    while (gcd($e, $phi) != 1 && $e < $phi) {
        $e++;
    }
    if ($e >= $phi) {
        echo 'e bigger than phi - fail';
        return;
    }
    list($d, $j, $k) = extended_gcd($e, $phi);
    if ($d < 0) {
        $d += $phi;
    }
    return array($n, $e, $d);
}

function smd($num, $den)
{
    $g = gcd($num, $den);
    return $den / $g;
}

function fractionreduce()
{
    $args = func_get_args();
    $retarr = false;
    if (count($args) == 1) {
        if (is_array($args[0])) {
            $f = $args[0];
        } else {
            $f = fractionparse($args[0]);
        }
    } else {
        if (count($args) == 2 && is_array($args[0])) {
            $f = $args[0];
            $retarr = $args[1];
        } else {
            if (count($args) == 2) {
                $f = array($args[0], $args[1]);
            } else {
                if (count($args) == 3) {
                    $f = array($args[0], $args[1]);
                    $retarr = $args[2];
                }
            }
        }
    }
    $g = gcd($f[0], $f[1]);
    $f[0] /= $g;
    $f[1] /= $g;
    if ($f[1] < 0) {
        $f[0] *= -1;
        $f[1] *= -1;
    }
    if ($retarr) {
        return $f;
    }
    if ($f[1] == 1) {
        return $f[0];
    } else {
        return $f[0] . '/' . $f[1];
    }
}

function fraction_divide($level)
{
    if ($level <= 3) {
        $num1 = rand(1, 2);
        $num2 = rand(1, 2);
        $denom1 = rand(1, 3);
        $denom2 = rand(1, 3);
    } elseif ($level <= 6) {
        $num1 = rand(3, 5);
        $num2 = rand(3, 5);
        $denom1 = rand(5, 10);
        $denom2 = rand(5, 10);
    } else {
        $num1 = rand(5, 10);
        $num2 = rand(5, 10);
        $denom1 = rand(10, 20);
        $denom2 = rand(10, 20);
    }
    $frac1 = $num1 / $denom1;
    $frac2 = $num2 / $denom2;
    $num = $num1 * $denom2;
    $denom = $denom1 * $num2;
    $gcd = gcd($num, $denom);
    if ($gcd) {
        $num /= $gcd;
        $denom /= $gcd;
    }
    $question = 'Mennyi lesz az alábbi művelet eredménye? $$\\frac{' . $num1 . '}{' . $denom1 . '}:\\frac{' . $num2 . '}{' . $denom2 . '}$$';
    $solution = '$\\frac{' . $num . '}{' . $denom . '}$';
    $correct = array($num, $denom);
    $type = 'fraction';
    return array('question' => $question, 'correct' => $correct, 'solution' => $solution, 'type' => $type);
}

function simplexpivot($sm, $pivotpoint)
{
    if (!is_array($pivotpoint)) {
        $pivotpoint = explode(',', $pivotpoint);
    }
    $Pivotrow = $pivotpoint[0];
    $Pivotcol = $pivotpoint[1];
    $PivotValue = $sm[$Pivotrow][$Pivotcol];
    // change pivot point to a one
    for ($j = 0; $j < count($sm[$Pivotrow]); $j++) {
        $top = $sm[$Pivotrow][$j][0] * $PivotValue[1];
        $bot = $sm[$Pivotrow][$j][1] * $PivotValue[0];
        if ($bot < 0) {
            $top *= -1;
            $bot *= -1;
            // must be positive
        }
        $gcf = gcd($top, $bot);
        $top /= $gcf;
        $bot /= $gcf;
        $sm[$Pivotrow][$j] = array($top, $bot);
        // divide by $PivotValue
    }
    // now zero out all other values in that row
    for ($r = 0; $r < count($sm); $r++) {
        if ($r != $Pivotrow) {
            $PivotValue = array(-$sm[$r][$Pivotcol][0], $sm[$r][$Pivotcol][1]);
            for ($c = 0; $c < count($sm[$r]); $c++) {
                // multiplication
                $top = $PivotValue[0] * $sm[$Pivotrow][$c][0];
                $bot = $PivotValue[1] * $sm[$Pivotrow][$c][1];
                // addition
                $top = $top * $sm[$r][$c][1] + $sm[$r][$c][0] * $bot;
                $bot = $bot * $sm[$r][$c][1];
                if ($bot < 0) {
                    $top *= -1;
                    $bot *= -1;
                    // must be positive
                }
                $gcf = gcd($top, $bot);
                $top /= $gcf;
                $bot /= $gcf;
                $sm[$r][$c] = array($top, $bot);
            }
        }
    }
    return $sm;
}

<?php

require "example.php";
# Call our gcd() function
$x = "42 aaa";
$y = 105;
$g = gcd($x, $y);
print "The gcd of {$x} and {$y} is {$g}\n";
# Manipulate the Foo global variable
# Output its current value
print "Foo = " . Foo_get() . "\n";
# Change its value
Foo_set(3.1415926);
# See if the change took effect ( this isn't a good example for php, see
#				  manual for why. )
print "Foo = " . Foo_get() . "\n";
print_Foo();

 public static function order_mod($x, $m)
 {
     if (extension_loaded('gmp') && USE_EXT == 'GMP') {
         if ($m <= 1) {
             return 0;
         }
         if (gcd($x, m) == 1) {
             $z = $x;
             $result = 1;
             while ($z != 1) {
                 $z = gmp_strval(gmp_Utils::gmp_mod2(gmp_mul($z, $x), $m));
                 $result = gmp_add($result, 1);
             }
             return gmp_strval($result);
         }
     } elseif (extension_loaded('bcmath') && USE_EXT == 'BCMATH') {
         if ($m <= 1) {
             return 0;
         }
         if (gcd($x, m) == 1) {
             $z = $x;
             $result = 1;
             while ($z != 1) {
                 $z = bcmod(bcmul($z, $x), $m);
                 $result = bcadd($result, 1);
             }
             return $result;
         }
     } else {
         throw new ErrorException("Please install BCMATH or GMP");
     }
 }

function lowestTerm($e)
{
    $part = explode('/', $e);
    $gcd = gcd($part[0], $part[1]);
    return $gcd;
}

function simplify($var, $num)
{
    $result = 0;
    $var = str_replace('x', '', $var);
    if (fmod($num, $var) == 0) {
        $result = $num / $var;
    } else {
        $gcd = gcd($num, $var);
        $num /= $gcd;
        $var /= $gcd;
        $result = "{$num}/{$var} or " . round($num / $var, 2);
    }
    return $result;
}