Explain 0-extension algorithm I'm trying to implement an approximation algorithm for the 0-extension problem

I found the following paper: 


  Approximation Algorithms for the
  0-extension problem by Gruia
  Calinescu, Howard Karloff and Yuval
  rabani.


On page 5 they explain the algorithm
but I don't understand it (I'm not English and some words are difficult to understand)

so can someone explain the algorithm from an implementation standpoint?

As input data (numbers are for illustration), I have a graph with 64 vertexes and a number of connections (no info about the max degree)
every connection has a "distance" defined
I want to colour the vertices with 3 colours
some vertices already have a colour

How do I do this? I'm pretty advanced software designer so you can use high-level pseudo-code

EDIT


  $\delta(u,v) = d(f(u),f(v))$


What do they mean with $f(\cdot)$?
Aren't $d$ and $\delta$ the "distance" functions?


  minimize $\sum_{uv \in E} c(u,v) \delta(u,v)$


Where is the $c(\cdot)$ coming from?
Cost function?

Rounding procedure:


  set $f(t) = t$ for all terminals


Are the terminals the colors or the vertices or vertices with a color assigned?


  such that $\delta(u,\sigma_j) \leq \alpha A_u$


What is $A_u$?
What is $\sigma_j$?

edit2

ok so i need to compose the equasions and solve them with a LP solver

lets take this example:
http://i77.photobucket.com/albums/j74/bertyhell/Diagram1.png
I want to know what colour to give B and C
in this case the best solution is to give C the red colour and B a green colour (B and A are furthest from each other)

2 terminals already have a color
and every edge as a "distance"
my cost function is: 

int c(u,v){
    if(u.color == undef || v.color == undef){
        return undef //unknown cost
    }else if(u.color == v.color){
        return 90 - "distance"
    }else{
        return 0 //no cost
    }
}


how do I put this in an equation?

and won't the equation system be undefined if there are to many terminals without a colour?

and if it isn't undefined, wont the first step solve the whole 0-extension problem?
Page 1 explains how you can go from the $\delta$-based formulation to the $f$-based formulation and back. But it doesn't matter for the algorithm. The first step is to solve the LP, thus obtaining values for the $\delta(i, j)$ values. From a pseudocode standpoint, you solve this by calling your favorite LP solver.
$c$ is the cost per edge, and is part of the input.
Terminals are the elements of the tree T (also given as part of the input)
$A_u$ is defined in the line above the text 'Rounding procedure' as the minimum distance between u and elements of T. 
\sigma_j denotes the jth element of T in some random ordering of the elements (basically scramble the array of indices corresponding to T and take the jth element)