value = ( x / max ) * 255

for (x = 0; x < 100; x++)
{
    PutPixel(x, 0, (x*255)/100);
}

czerwony = R << 16 = R * (256 * 256) = R * 65536
zielony = G << 8 = G * 256
niebieski = B

value = ( R << 16 ) | ( G << 8 ) | B;

value = ( R * 65536 ) | ( G * 256 ) | B;

for (x = 0; x <= 100; x++)
{
    value = (x*255)/100;
    PutPixel(x, 0, (value << 16) | (value << 8));
}

for (x = 0; x <= 100; x++)
{
    value = (x*255)/100;
    PutPixel(x, 0, (value << 16) | ((255-value) << 8));
}

A = 100, B = 200, max = 5.
Czyli mamy 6 kroków od A do B - bo zerowy krok też liczymy (więc max + 1).
W tym:
krok(0) = A = 100
krok(5) = B = 200

value = (B - A)*pos/max + A;

1. Separujemy składowe RGB z wejść A i B - np do tablicy.
2. Na każdej parze składowych pobranych z kolorów A i B wykonujemy interpolację i wynik umieszczamy w tablicy C.
3. Łączymy składowe z tablicy C do koloru i zwracamy wynik.

function Interpolate2Colors($A, $B, $pos, $max_pos)
{
    // Separujemy kanały
    $A_R = $A >> 16;
    $A_G = ($A >> 8) & 0xff;
    $A_B = $A & 0xff;

    $B_R = $B >> 16;
    $B_G = ($B >> 8) & 0xff;
    $B_B = $B & 0xff;

    //Interpolujemy wartości na kanałach
    $C_R = (($B_R - $A_R)*$pos)/$max_pos + $A_R;
    $C_G = (($B_G - $A_G)*$pos)/$max_pos + $A_G;
    $C_B = (($B_B - $A_B)*$pos)/$max_pos + $A_B;

    //Scalamy kanały wyniku
    $C = ($C_R << 16) + ($C_G << 8) + $C_B;

    return $C;
}

function Interpolate2Colors(A, B, pos, max)
{
    C = (((B & 0xff) - (A & 0xff))*pos)/max + (A & 0xff); // liczymy B
    C = C + ((( ((B >> 8) & 0xff) - ((A >> 8) & 0xff) )*pos)/max + ((A >> 8) & 0xff)) << 8; // dodajemy G
    C = C + ((( ((B >> 16) & 0xff) - ((A >> 16) & 0xff) )*pos)/max + ((A >> 16) & 0xff)) << 16; // dodajemy R
    return C;
}

for (x = 0; x <= 100; x++)
{
    PutPixel(x, 0, Interpolate2Colors(0xFFFF00, 0xFF00FF, x, 100) );
}

function Interpolate3Colors($c1, $c2, $c3, $value, $max_value)
{
    if ($value < $max_value/2)
        $color = Interpolate2Colors($c1, $c2, $value, $max_value/2);
    else
        $color = Interpolate2Colors($c2, $c3, $value - $max_value/2, $max_value/2);
    return $color;
}

definicja gradientu:
{
    gradient(0) - kolor: 0x8080FF, pozycja: 0
    gradient(1) - kolor: 0xC0FFFF, pozycja: 420
    gradient(2) - kolor: 0xFFFFFF, pozycja: 499
    gradient(3) - kolor: 0x008000, pozycja: 500
    gradient(4) - kolor: 0xC0FFC0, pozycja: 570
    gradient(5) - kolor: 0x008000, pozycja: 1000
}

1. Przeszukujemy naszą strukturę danych zawierającą definicję gradientu, w poszukiwaniu wartości najbliższych. Widać, że są to kroki numer 3 i 4 (bo gradient(3) jest w pkt 500, a gradient(4) w pkt 570).
2. Przeliczamy interpolację standardową funkcją (Interpolate2Colors) podając jej:
- pierwszy kolor: gradient(3) 0x008000
- drugi kolor: gradient(4) 0xC0FFC0
- pos: nasza poszukiwana pozycja minus pozycja gradient(3) 530 - 500 = 30
- max_pos: różnica między pozycjami gradient(3) i gradient(4) 570 - 500 = 70

for (y = 0; y <= 100; y++)
{
    alpha = 100 - y;
    for (x = 0; x <= 100; x++)
    {
        color = Interpolate2Colors( 0xFFFF00, 0x00FFFF, x, 100);
        color_cieniowany = Interpolate2Colors( 0x000000, color, alpha, 100);
        PutPixel(x, y, color_cieniowany);
    }
}