Algorithms

Im building a indoor putting ramp and it will be possible to hit straight puts but also I will create breaks for variation.
I asking for help for an algorithm and the easy part of this is that the slopes will be fixed.

Imagine this like a pooltable. If a raise one side with 3cm. Which is 3 degrees  to make it easy.
How much do I have to change my aim point compared to the straight putt?


Summary:
What I would like for this in the beginning.

Distance 1,2,3 Meters.
Fixed break. (Means the slope is the same on the entire surface)
Break 1,2,3,4 degrees.

2 different speeds:
One speed that the ball just make it to the hole.
Second speed that the ball ends up 70 cm behind the ball?

Why different speeds?
To show and illustrate how the aim point changes depending on how hard you roll the ball.

int mySqrt(int x, int left, int right)
{
    static int result = 0;
    if (left <= right)
    {
        int middle = left + (right - left) / 2;
        if ((middle != 0 && middle <= x / middle) ||
            (middle == 0 && middle <= x / (middle + 1)))
        {
            result = middle;
            return mySqrt(x, middle + 1, right);
        }
        else
        {
            return mySqrt(x, left, middle - 1);
        }
    }
    return result;
}

const GROUPS_COUNTER = 10;
const MIN_ASCII = 65;
const MAX_ASCII = 69;

/*
 * generate children pairs.
 */
function generateGroups($n) {
    $matrix = [];
    $exist = [];
    echo "************************\n";

    for ($i = 0; $i < $n; $i++) {
        $a = chr(rand(MIN_ASCII, MAX_ASCII));
        $b = chr(rand(MIN_ASCII, MAX_ASCII));

        if ($a == $b || isset($exist[$a][$b]) || isset($exist[$b][$a])) {
            $i--;
            continue;
        }

        $matrix[$i][0] = $a;
        $matrix[$i][1] = $b;
        $exist[$a][$b] = true;

        echo $a . " " . $b . "\n";
    }

    echo "************************\n";

    return $matrix;
}

/*
 * find all children which are not like by parent.
 */
function findGroups($groups) {
    $dislikeList = [];
    $checked = [];

    foreach ($groups as $groupParent) {
        if (isset($checked[$groupParent[0]])) {
            continue;
        }

        $groupChildList = [];

        foreach ($groups as $groupChild) {
            if ($groupParent[0] == $groupChild[0]) {
                array_push($groupChildList, $groupChild[1]);
            }
        }

        echo $groupParent[0] . " => " . implode(", ", $groupChildList) . "\n";
        $dislikeList[$groupParent[0]] = $groupChildList;
        $checked[$groupParent[0]] = true;
    }

    echo "************************\n";

    return $dislikeList;
}

/*
 * phpTarjanEntry() iterates through the graph array rows, executing phpTarjan().
 */
function phpTarjanEntry($groups) {
    global $cycles;
    global $marked;
    global $markedStack;
    global $pointStack;

    $cycles = array();
    $marked = array();
    $markedStack = array();
    $pointStack = array();

    $marked = array();

    foreach ($groups as $key => $value) {
        $marked[$key] = FALSE;
    }

    foreach ($groups as $key => $value) {
        phpTarjan($key, $key);

        while (!empty($markedStack)) {
            $marked[array_pop($markedStack)] = FALSE;
        }
    }

    $cycles = array_keys($cycles);

    return $cycles;
}

/*
 * Recursive function to detect strongly connected components (cycles, loops).
 */
function phpTarjan($s, $v) {
    global $G;
    global $cycles;
    global $marked;
    global $markedStack;
    global $pointStack;

    $f = FALSE;
    $pointStack[] = $v;
    $marked[$v] = TRUE;
    $markedStack[] = $v;

    foreach ($G[$v] as $w) {
        if ($w < $s) {
            $G[$w] = array();
        } else if ($w == $s) {
            $cycles[implode('|', $pointStack)] = TRUE;
            $f = TRUE;
        } else if (isset($marked[$w]) && $marked[$w] === FALSE) {
            $g = phpTarjan($s, $w);

            if (!empty($f) OR ! empty($g)) {
                $f = TRUE;
            }
        }
    }

    if ($f === TRUE) {
        while (end($markedStack) != $v) {
            $marked[array_pop($markedStack)] = FALSE;
        }

        array_pop($markedStack);
        $marked[$v] = FALSE;
    }

    array_pop($pointStack);
    return $f;
}

$mixGroups = generateGroups(GROUPS_COUNTER);
$res = findGroups($mixGroups);
$G = $res;
$cycles = phpTarjanEntry($res);

echo '<p>Cycles found: ' . count($cycles);
print_r($cycles);

from numpy import *
import sys
import numpy as np
x=1
epsilon=sys.float_info.epsilon/2.0
# machine epsilon
h = np.linspace(1,epsilon,1000)
e1= (((sin(x)- sin(x-h))/h-cos(x))/cos(x))                      #realtive error in first order
e2= (((sin(x-2*h)-4*sin(x-h)+3*sin(x))/(2*h)-cos(x))/cos(x))    #realtive error in second order
e3= (((2*sin(x+h)+3*sin(x)-6*sin(x-h)+sin(x-2*h))/(6*h)-cos(x))/cos(x))#realtive error in third order
e4 = (((-sin(x-3*h)+6*sin(x-2*h)-18*sin(x-h)+10*sin(x)+3*sin(x+h))/(12*h)-cos(x))/cos(x))#realtive error in fourth order
print(h)
import matplotlib.pyplot as plt
plt.plot(h,e1,'-b',lw=3)
plt.plot(h,e2,'-g',lw=3)
plt.plot(h,e3,'-m',lw=3)
plt.plot(h,e4,'-r',lw=3)
plt.xscale('log')
plt.yscale('log')
plt.xlabel('h')
plt.ylabel('Relative error')
plt.legend(['first order','second order','third order','fourth order'])
plt.title('Effect of order of accuracy on the numerical differentiation')
plt.show()