Конвертирование Delphi->C#

[templllar]

Может кто-нибудь помочь перевести Delphi код в C# ? код очень простой, но С# не знаю..

const CountF=3;
type
Arr=array[0..1] of real;
Arr2=array [0..1,0..1] of real;
Arr3=array [0..2,0..1] of real;
ArrSimp=array[0..2] of real;
type
TLogic= class
public
procedure Dihotomiya(a,b,eps:real;var Iter:Integer;var AnswerX:real;var Answerf:real);
procedure Newton(x,y,eps:real;var Iter:Integer;var AnswerX:Arr;var Answerf:real);
procedure Simplex(eps,x,y:real;var Answer:Arr; var Answerf:real;var Iter:integer);
private
function f(x:real):real;
function Round(x,eps:real):real;
function df(x:Arr):Arr;
function proizv(x:Arr;y:Arr2):Arr;
function Gesse(x:Arr):Arr2;
function df2(X11:Arr2;x:Arr):Arr2;
function SimpF(x,y:real): real;
end;
implementation

procedure TLogic.Dihotomiya(a,b,eps:real;var Iter:Integer;var AnswerX:real;var Answerf:real);
var
x1,x2,delta,f1,f2,EpsMeth:real;
Begin
Iter:=0;
delta:=eps/4;
repeat
Iter:=Iter+1;
x1:=(a+b-delta)/2;
x2:=(a+b+delta)/2;
f1:=f(x1);
f2:=f(x2);
if f1<=f2 then
b:=x2
else
a:=x1;
EpsMeth:=(b-a)/2;
until EpsMeth<=eps;
AnswerX:=(a+b)/2;
Answerf:=f(AnswerX);
end;


function TLOgic.f(x:real):real;
var Temp:real;
Begin
Temp:=Exp(-x)+Math.Power(x,4);
Result:= Temp;
end;




procedure TLogic.Newton(x,y,eps:real;var Iter:Integer;var AnswerX:Arr;var Answerf:real);
var
it1:integer;
x0,x1: Arr; //ïåðåìåííûå
df1,proiz:Arr;
Gess:Arr2;
Begin
Iter:=0;
x1[0]:=x;
x1[1]:=y;
repeat
x0:=x1;
Gess:=Gesse(x0);
Iter:=Iter+1;
df1:=df(x0);
Gess:=df2(Gess,x0);
proiz:=proizv(df1,Gess);
for it1:=0 to Length(x1)-1 do
x1[it1]:=x0[it1]- proiz[it1];
until ((Abs(x1[0]-x0[0])<=eps) AND ((Abs(x1[1]-x0[1])<=eps)) OR (Iter=50));
AnswerX:=x1;
Answerf:=0;
end;

function TLogic.df(x:Arr):Arr;
var Temp:Arr;
Begin
// Temp[0]:=3*SQR(x[0])-3;
// Temp[1]:=2*x[1]-2;
// Temp[0]:=8*x[0]-4*x[1]+1;
// Temp[1]:=6*x[1]-4*x[0];
Temp[0]:=2*x[0]-40*x[0]*(x[1]-Sqr(x[0]))-2;
Temp[1]:=20*x[1]-20*Sqr(x[0]);
//Temp[0]:=(exp(-0.5*x[0])*(-0.5-0.5*sqr(x[0])+2*x[0]))*sin(x[1]);
//Temp[1]:=(1+sqr(x[0]))*exp(-0.5/x[0])*cos(x[1]);
Result:=Temp;

end;


function TLogic.proizv(x:Arr;y:Arr2):Arr;

var Temp:Arr;
i,j:integer;
Begin
for i:=0 to Length(x)-1 do
Temp[i]:=0;
for i:=0 to Length(x)-1 do
for j:=0 to Length(x)-1 do
Temp[i]:=x[j]*y[j,i]+Temp[i];
Result:=Temp;
end;

function TLogic.Gesse(x:Arr):Arr2;
var Temp:Arr2;
Begin
Temp[0,0]:=120*Sqr(x[0])-40*x[1]+2;
Temp[0,1]:=-40*x[0];
Temp[1,0]:=Temp[0,1];
Temp[1,1]:=20;
result:=Temp;
End;



function TLogic.df2(X11:Arr2;x:Arr):Arr2;
var i,j:integer;
TempVal1,Opred:real;
Begin
Opred:=X11[0,0]*X11[1,1]-X11[1,0]*X11[0,1];
if Opred<>0 then
Begin
TempVal1:=X11[0,0];
X11[0,0]:=X11[1,1];
X11[1,1]:=TempVal1;
TempVal1:=X11[1,0];
X11[1,0]:=X11[0,1];
X11[0,1]:=TempVal1;
for i:=0 to Length(x)-1 do
for j:=0 to Length(x)-1 do
X11[i,j]:=Math.Power(-1,i+j) *X11[i,j]/Opred;
end;
Result:=X11;


end;

[Arnezami]

могу попробовать но где то в среду)))

[akasex]

public class D2C
    {
        private double F(double x)
        {
            return Math.Exp(-x) + Math.Pow(x, 4);
        }

        private double[,] Gesse(double[] x)
        { 
            double[,] Temp = new double[2, 2];
            Temp[0, 0] = 120 * (x[0] * x[0]) - 40 * x[1] + 2;
            Temp[0, 1] = -40 * x[0];
            Temp[1, 0] = Temp[0, 1];
            Temp[1, 1] = 20;
            return Temp;
        }

        private double[] DF(double[] x)
        { 
            double[] Temp = new double[2];
            Temp[0] = 2 * x[0] - 40 * x[0] * (x[1] - (x[0] * x[0])) - 2;
            Temp[1] = 20 * x[1] - 20 * (x[0] * x[0]);
            return Temp;
        }

        private double[,] DF2(double[,] x11, double[] x)
        { 
            double TempVal1, Opred;
            Opred = x11[0, 0] * x11[1, 1] - x11[1, 0] * x11[0, 1];
            if (Opred != 0)
            {
                TempVal1 = x11[0, 0];
                x11[0, 0] = x11[1, 1];
                x11[1, 1] = TempVal1;
                TempVal1 = x11[1, 0];
                x11[1, 0] = x11[0, 1];
                x11[0, 1] = TempVal1;
                for (int i = 0; i < x.Length - 1; i++)
                {
                    for (int j = 0; j < x.Length - 1; j++)
                    {
                        x11[i, j] = Math.Pow(-1, i + j) * x11[i, j] / Opred;
                    }
                }
            }
            return x11;
        }

        private double[] Proizv(double[] x, double[,] y)
        { 
            double[] Temp = new double[2];
            for (int i = 0; i < x.Length - 1; i++)
            {
                Temp[i] = 0;
            }
            for (int i = 0; i < x.Length - 1; i++)
            {
                for (int j = 0; j < x.Length - 1; j++)
                {
                    Temp[i] = x[j] * y[j, i] + Temp[i];
                }
            }
            return Temp;       
        }

        public void Dihotomiya (double a, double b, double eps, int Iter,
            out double AnswerX, out double Answerf)
        {
            Iter = 0;
            double delta = eps / 4;
            double x1, x2, f1, f2, EpsMeth;
            do 
            {
                Iter++;
                x1 = (a + b - delta) / 2;
                x2 = (a + b + delta) / 2;
                f1 = this.F(x1);
                f2 = this.F(x2);
                if (f1 <= f2)
                {
                    b = x2;
                }
                else
                {
                    a = x1;
                }
                EpsMeth = (b - a) / 2;
            } while (EpsMeth <= eps);
            AnswerX = (a + b) / 2;
            Answerf = this.F(AnswerX);
        }

        public void Newton(double x, double y, double eps, int Iter,
            out double[] AnswerX, out double Answerf)
        {
            double[] x0, x1, df1, proiz;
            double[,] Gess = new double[2, 2];
            Iter = 0;
            x0 = new double[2];
            x1 = new double[2];
            df1 = new double[2];
            proiz = new double[2];
            x1[0] = x;
            x1[1] = y;
            do
            {
                x0 = x1;
                Gess = this.Gesse(x0);
                Iter++;
                df1 = this.DF(x0);
                Gess = this.DF2(Gess, x0);
                proiz = this.Proizv(df1, Gess);
                for (int it1 = 0; it1 < x1.Length - 1; it1++)
                {
                    x1[it1] = x0[it1] - proiz[it1];
                }
            } while ((Math.Abs(x1[0] - x0[0]) <= eps) && ((Math.Abs(x1[1] - x0[1]) <= eps))
            || (Iter == 50));
            AnswerX = x1;
            Answerf = 0;
        }
    }