[DarkDudae]

Escribo nuevamente para comentaros que ya he podido solucionar el problema. Al final lo he conseguido mediante el método de Levenberg-Maxquadrat. En las librerías de ALGLIB podemos encontrar una implementación del mismo.

La parte más "compleja" es que hay que calcular las derivadas de cada una de las incógnitas para mejorar el proceso de convergencia. Pero bueno, lo dejo aquí por si le puede ser de ayuda a alguien en un futuro por si tiene que minimizar funciones complejas.

 Memo1.Clear;
    //Tenemos 4 incógnitas: A, Xk, B, XLa
    N := 4;

    SetLength(S, N);

    //S: Nuestra aproximación inicial que sabemos no excesivamente alejada de la realidad
    S[0]:=250; S[1]:=750; S[2]:=200; S[3]:=775;

    M := 120;
    SetLength(X1, M);
    SetLength(Y1, M);
    I:=0;
    while I<=M-1 do
    begin
        X1[i] := 700+I;
        //Leemos los 120 valores de un memo (mValores) o cualquier stream
        Y1[i] := strtofloat(mValores.Lines[i]);
        Inc(I);
    end;

    //Ahora S almacena los puntos de inicio, mientras que X e Y almacenan los puntos que serán "suavizados y/o minimizados"
    MinLMCreateFJ(N, M, S, State);
    MinLMSetCond(State, 0.0, 0.0, 0.001, 0);
    while MinLMIteration(State) do
    begin

        if State.NeedF then
        begin
            State.F := 0;
        end;
        I:=0;
        while I<=M-1 do
        begin

            //
            // "A" guardada en State.X[0]
            // "Xk" - State.X[1]
            // "B" - State.X[2]
            // "XLa" - State.X[3]
            //

            FI := Y1[i]-State.X[0]*exp((-1)*((AP_Sqr(X1[i]-State.X[1])/(2*AP_Sqr(6.3)))))-State.X[2]*exp((-1)*((AP_Sqr(X1[i]-State.X[3])/(2*AP_Sqr(6.3)))));

            if State.NeedF then
            begin
               //Sumatorio aquí
                State.F := State.F+AP_Sqr(FI);
            end;
            if State.NeedFiJ then
            begin
                //
                // Fi
                //
                State.Fi[i] := FI;

                //
                // dFi/dA = -exp^(-((x-Xk)^2)/2s^2)
                //
                State.J[I,0] := (-1)*exp((-1)*((AP_Sqr(X1[i]-State.X[1])/(2*AP_Sqr(6.3)))));
                //
                // dFi/dXk = (A*(xK-x)*exp(-(((x-Xk)^2)/(2*s^2))))))/(6.3^2))

                //
                State.J[I,1] := (State.X[0]*(State.X[1]-X1[i])*exp((-1)*((AP_Sqr(X1[i]-State.X[1])/(2*AP_Sqr(6.3))))))/(AP_Sqr(6.3));

                //
                // dFi/dB = -exp^(-((x-XL)^2)/2s^2) 
                //
                State.J[I,2] := (-1)*exp((-1)*((AP_Sqr(X1[i]-State.X[3])/(2*AP_Sqr(6.3)))));

                //
                // dFi/dXLa = (B*(xL-x)*exp(-(((x-xL)^2)/(2*s^2))))))/(6.3^2))
                //
                State.J[I,3] := (State.X[2]*(State.X[3]-X1[i])*exp((-1)*((AP_Sqr(X1[i]-State.X[3])/(2*AP_Sqr(6.3))))))/(AP_Sqr(6.3));


            end;
            Inc(I);
        end;
    end;
    MinLMResults(State, S, Rep);

    //
    // output results
    //
    Memo1.Lines.Add(Format('A = %4.2f'#13#10'',[
        S[0]]));
    Memo1.Lines.Add(Format('Xk = %4.2f'#13#10'',[
        S[1]]));
    Memo1.Lines.Add(Format('B = %4.2f'#13#10'',[
        S[2]]));
    Memo1.Lines.Add(Format('XLa = %4.2f'#13#10'',[
        S[3]]));
    Memo1.Lines.Add(Format('Tipo de terminación = %0d (debería ser 2 - parando cuando sea suficientemente pequeño)'#13#10'',[
        Rep.TerminationType]));