Keskustelu: Ohjelmointikysymykset: VB.net kääntö C# ja eri tulos

juffe [15.01.2020 16:31:51]

Eli koitan tuota laskukaavaa kääntää vb.net -> C# tulos on väärä C#.

Vastauksena VB.NET koodissa on NN: 7004642,085 EE: 230333,319 joka on oikein
Ja vastauksena C# koodissa on: NN: 7000319,210 EE: 230066,713 joka on VÄÄRIN

Mikä tässä nyt mättää?

Alla VB-NET ja C# koodi.

public static class MyMath
{
    public static double Arctanh(double Value)
    {


        return Math.Log((1 / Value + 1) / (1 / Value - 1)) / 2;

    }


}
public static class MyMath2
{

     public static double Asinh(double Value2)
     {

        return Math.Log(Value2 + (Math.Sqrt(Value2 * Value2 + 1)));
    }

}


Double f;
Double a;
Double lambda_nolla;
Double k_nolla;
Double E_nolla;
Double fii;
Double lambda;
Double n;
Double A1;
Double e_toiseen;
Double h1_pilkku;
Double h2_pilkku;
Double h3_pilkku;
Double h4_pilkku;
Double Q_pilkku;
Double Q_2pilkku;
Double Q;
Double l;
Double beeta;
Double eeta_pilkku;
Double zeeta_pilkku;
Double zeeta1;
Double zeeta2;
Double zeeta3;
Double zeeta4;
Double eeta1;
Double eeta2;
Double eeta3;
Double eeta4;
Double zeeta;
Double eeta;

Double NN;
Double EE;
Double pi;
pi = 3.14159265358979;


f = 1 / 298.257222101;
a = 6378137;
lambda_nolla = 0.471238898;

k_nolla = 0.9996;

E_nolla = 500000;

fii = (63.07032 * pi) / 180;
lambda = (21.65874 * pi) / 180;

n = f / (2 - f);
A1 = (a / (1 + n)) * (1 + (n * n) / 4) + ((n * n * n * n) / 64);
e_toiseen = (2 * f) - (f * f);

h1_pilkku = (1 / 2) * n - (2 / 3) * (n * n) + (5 / 16) * (n * n * n) + (41 / 180) * (n * n * n * n);
h2_pilkku = (13 / 48) * (n * n) - (3 / 5) * (n * n * n) + (557 / 1440) * (n * n * n * n);
h3_pilkku = (61 / 240) * (n * n * n) - (103 / 140) * (n * n * n * n);
h4_pilkku = (49561 / 161280) * (n * n * n * n);
Q_pilkku = MyMath2.Asinh(Math.Tan(fii));
Q_2pilkku = MyMath.Arctanh(Math.Sqrt(e_toiseen) * Math.Sin(fii));
Q = Q_pilkku - Math.Sqrt(e_toiseen) * Q_2pilkku;
l = lambda - lambda_nolla;
beeta = Math.Atan(Math.Sinh(Q));
eeta_pilkku = MyMath.Arctanh(Math.Cos(beeta) * Math.Sin(l));
zeeta_pilkku = Math.Asin(Math.Sin(beeta) / (1 / Math.Cosh(eeta_pilkku)));
zeeta1 = h1_pilkku * Math.Sin(2 * zeeta_pilkku) * Math.Cosh(2 * eeta_pilkku);
zeeta2 = h2_pilkku * Math.Sin(4 * zeeta_pilkku) * Math.Cosh(4 * eeta_pilkku);
zeeta3 = h3_pilkku * Math.Sin(6 * zeeta_pilkku) * Math.Cosh(6 * eeta_pilkku);
zeeta4 = h4_pilkku * Math.Sin(8 * zeeta_pilkku) * Math.Cosh(8 * eeta_pilkku);
eeta1 = h1_pilkku * Math.Cos(2 * zeeta_pilkku) * Math.Sinh(2 * eeta_pilkku);
eeta2 = h2_pilkku * Math.Cos(4 * zeeta_pilkku) * Math.Sinh(4 * eeta_pilkku);
eeta3 = h3_pilkku * Math.Cos(6 * zeeta_pilkku) * Math.Sinh(6 * eeta_pilkku);
eeta4 = h4_pilkku * Math.Cos(8 * zeeta_pilkku) * Math.Sinh(8 * eeta_pilkku);
zeeta = zeeta_pilkku + zeeta1 + zeeta2 + zeeta3 + zeeta4;
eeta = eeta_pilkku + eeta1 + eeta2 + eeta3 + eeta4;

// Tulos tasokoordinaatteina
NN = A1 * zeeta * k_nolla;
EE = A1 * eeta * k_nolla + E_nolla;


    label3.Text = Convert.ToString(NN);
    textBox5.Text = Convert.ToString(EE);

Function ASinH(Value As Double) As Double
    ASinH = Math.Log(Value + Math.Sqrt(Value * Value + 1))
End Function

Function ATanH(value As Double) As Double
    ATanH = Math.Log((1 / value + 1) / (1 / value - 1)) / 2
End Function


    Dim f As Double
    Dim a As Double
    Dim lambda_nolla As Double
    Dim k_nolla As Double
    Dim E_nolla As Double
    Dim fii As Double
    Dim lambda As Double
    Dim n As Double
    Dim A1 As Double
    Dim e_toiseen As Double
    Dim h1_pilkku As Double
    Dim h2_pilkku As Double
    Dim h3_pilkku As Double
    Dim h4_pilkku As Double
    Dim Q_pilkku As Double
    Dim Q_2pilkku As Double
    Dim Q As Double
    Dim l As Double
    Dim beeta As Double
    Dim eeta_pilkku As Double
    Dim zeeta_pilkku As Double
    Dim zeeta1 As Double
    Dim zeeta2 As Double
    Dim zeeta3 As Double
    Dim zeeta4 As Double
    Dim eeta1 As Double
    Dim eeta2 As Double
    Dim eeta3 As Double
    Dim eeta4 As Double
    Dim zeeta As Double
    Dim eeta As Double

    Dim NN As Double
    Dim EE As Double
    Dim pi As Double
    pi = 3.14159265358979


    f = 1 / 298.257222101
    a = 6378137
    lambda_nolla = 0.471238898
    k_nolla = 0.9996
    E_nolla = 500000



    fii = (63.07032 * pi) / 180
    lambda = (21.65874 * pi) / 180

    n = f / (2 - f)
    A1 = (a / (1 + n)) * (1 + (n * n) / 4) + ((n * n * n * n) / 64)
    e_toiseen = (2 * f) - (f * f)
    h1_pilkku = (1 / 2) * n - (2 / 3) * (n * n) + (5 / 16) * (n * n * n) + (41 / 180) * (n * n * n * n)
    h2_pilkku = (13 / 48) * (n * n) - (3 / 5) * (n * n * n) + (557 / 1440) * (n * n * n * n)
    h3_pilkku = (61 / 240) * (n * n * n) - (103 / 140) * (n * n * n * n)
    h4_pilkku = (49561 / 161280) * (n * n * n * n)
    Q_pilkku = ASinH(Math.Tan(fii))
    Q_2pilkku = ATanH(Math.Sqrt(e_toiseen) * Math.Sin(fii))
    Q = Q_pilkku - Math.Sqrt(e_toiseen) * Q_2pilkku
    l = lambda - lambda_nolla
    beeta = Math.Atan(Math.Sinh(Q))
    eeta_pilkku = ATanH(Math.Cos(beeta) * Math.Sin(l))
    zeeta_pilkku = Math.Asin(Math.Sin(beeta) / (1 / Math.Cosh(eeta_pilkku)))
    zeeta1 = h1_pilkku * Math.Sin(2 * zeeta_pilkku) * Math.Cosh(2 * eeta_pilkku)
    zeeta2 = h2_pilkku * Math.Sin(4 * zeeta_pilkku) * Math.Cosh(4 * eeta_pilkku)
    zeeta3 = h3_pilkku * Math.Sin(6 * zeeta_pilkku) * Math.Cosh(6 * eeta_pilkku)
    zeeta4 = h4_pilkku * Math.Sin(8 * zeeta_pilkku) * Math.Cosh(8 * eeta_pilkku)
    eeta1 = h1_pilkku * Math.Cos(2 * zeeta_pilkku) * Math.Sinh(2 * eeta_pilkku)
    eeta2 = h2_pilkku * Math.Cos(4 * zeeta_pilkku) * Math.Sinh(4 * eeta_pilkku)
    eeta3 = h3_pilkku * Math.Cos(6 * zeeta_pilkku) * Math.Sinh(6 * eeta_pilkku)
    eeta4 = h4_pilkku * Math.Cos(8 * zeeta_pilkku) * Math.Sinh(8 * eeta_pilkku)
    zeeta = zeeta_pilkku + zeeta1 + zeeta2 + zeeta3 + zeeta4
    eeta = eeta_pilkku + eeta1 + eeta2 + eeta3 + eeta4

    ''// Tulos tasokoordinaatteina
    NN = A1 * zeeta * k_nolla
    EE = A1 * eeta * k_nolla + E_nolla

    TextBox3.Text = Math.Round(NN, 3)
    TextBox4.Text = Math.Round(EE, 3)

Grez [15.01.2020 17:06:58]

Suosittelen käyttämään parempaa kääntäjää. Et maininnut mitä olit käyttänyt

juffe [15.01.2020 17:16:54]

Visual Studio siis käytössä.

Grez [15.01.2020 17:26:36]

En usko hetkeäkään että Visual Studio olisi tehnyt tuollaista C# -> Vb.Net -käännöstä jossa funktioiden nimet muuttuu jne.

Tässä on suora* C# käännös tuosta VB.Net-koodistasi, ja se antaa saman NN: 7004642,085 EE: 230333,319 tuloksen:

*lisäsin vaan funktion ympärille että sai kääntymään.

public static double ASinH(double Value)
{
    return Math.Log(Value + Math.Sqrt(Value * Value + 1));
}

public static double ATanH(double value)
{
    return Math.Log((1 / value + 1) / (1 / value - 1)) / 2;
}


public static void DoIt()
{
    double f;
    double a;
    double lambda_nolla;
    double k_nolla;
    double E_nolla;
    double fii;
    double lambda;
    double n;
    double A1;
    double e_toiseen;
    double h1_pilkku;
    double h2_pilkku;
    double h3_pilkku;
    double h4_pilkku;
    double Q_pilkku;
    double Q_2pilkku;
    double Q;
    double l;
    double beeta;
    double eeta_pilkku;
    double zeeta_pilkku;
    double zeeta1;
    double zeeta2;
    double zeeta3;
    double zeeta4;
    double eeta1;
    double eeta2;
    double eeta3;
    double eeta4;
    double zeeta;
    double eeta;

    double NN;
    double EE;
    double pi;
    pi = 3.14159265358979;


    f = 1 / 298.257222101;
    a = 6378137;
    lambda_nolla = 0.471238898;
    k_nolla = 0.9996;
    E_nolla = 500000;



    fii = (63.07032 * pi) / 180;
    lambda = (21.65874 * pi) / 180;

    n = f / (2 - f);
    A1 = (a / (1 + n)) * (1 + (n * n) / 4) + ((n * n * n * n) / 64);
    e_toiseen = (2 * f) - (f * f);
    h1_pilkku = (1 / (double)2) * n - (2 / (double)3) * (n * n) + (5 / (double)16) * (n * n * n) + (41 / (double)180) * (n * n * n * n);
    h2_pilkku = (13 / (double)48) * (n * n) - (3 / (double)5) * (n * n * n) + (557 / (double)1440) * (n * n * n * n);
    h3_pilkku = (61 / (double)240) * (n * n * n) - (103 / (double)140) * (n * n * n * n);
    h4_pilkku = (49561 / (double)161280) * (n * n * n * n);
    Q_pilkku = ASinH(Math.Tan(fii));
    Q_2pilkku = ATanH(Math.Sqrt(e_toiseen) * Math.Sin(fii));
    Q = Q_pilkku - Math.Sqrt(e_toiseen) * Q_2pilkku;
    l = lambda - lambda_nolla;
    beeta = Math.Atan(Math.Sinh(Q));
    eeta_pilkku = ATanH(Math.Cos(beeta) * Math.Sin(l));
    zeeta_pilkku = Math.Asin(Math.Sin(beeta) / (1 / Math.Cosh(eeta_pilkku)));
    zeeta1 = h1_pilkku * Math.Sin(2 * zeeta_pilkku) * Math.Cosh(2 * eeta_pilkku);
    zeeta2 = h2_pilkku * Math.Sin(4 * zeeta_pilkku) * Math.Cosh(4 * eeta_pilkku);
    zeeta3 = h3_pilkku * Math.Sin(6 * zeeta_pilkku) * Math.Cosh(6 * eeta_pilkku);
    zeeta4 = h4_pilkku * Math.Sin(8 * zeeta_pilkku) * Math.Cosh(8 * eeta_pilkku);
    eeta1 = h1_pilkku * Math.Cos(2 * zeeta_pilkku) * Math.Sinh(2 * eeta_pilkku);
    eeta2 = h2_pilkku * Math.Cos(4 * zeeta_pilkku) * Math.Sinh(4 * eeta_pilkku);
    eeta3 = h3_pilkku * Math.Cos(6 * zeeta_pilkku) * Math.Sinh(6 * eeta_pilkku);
    eeta4 = h4_pilkku * Math.Cos(8 * zeeta_pilkku) * Math.Sinh(8 * eeta_pilkku);
    zeeta = zeeta_pilkku + zeeta1 + zeeta2 + zeeta3 + zeeta4;
    eeta = eeta_pilkku + eeta1 + eeta2 + eeta3 + eeta4;

    // '// Tulos tasokoordinaatteina
    NN = A1 * zeeta * k_nolla;
    EE = A1 * eeta * k_nolla + E_nolla;

    TextBox3.Text = Math.Round(NN, 3));
    TextBox4.Text = (Math.Round(EE, 3));
}

Lisäys:

Vika näyttäisi olevan näillä riveillä:

vb.net -koodista koneellisesti käännettynä:

h1_pilkku = (1 / (double)2) * n - (2 / (double)3) * (n * n) + (5 / (double)16) * (n * n * n) + (41 / (double)180) * (n * n * n * n);
h2_pilkku = (13 / (double)48) * (n * n) - (3 / (double)5) * (n * n * n) + (557 / (double)1440) * (n * n * n * n);
h3_pilkku = (61 / (double)240) * (n * n * n) - (103 / (double)140) * (n * n * n * n);
h4_pilkku = (49561 / (double)161280) * (n * n * n * n);

Sinun laittamasi koodi:

h1_pilkku = (1 / 2) * n - (2 / 3) * (n * n) + (5 / 16) * (n * n * n) + (41 / 180) * (n * n * n * n);
h2_pilkku = (13 / 48) * (n * n) - (3 / 5) * (n * n * n) + (557 / 1440) * (n * n * n * n);
h3_pilkku = (61 / 240) * (n * n * n) - (103 / 140) * (n * n * n * n);
h4_pilkku = (49561 / 161280) * (n * n * n * n);

Eli laittamassasi VB.net -koodissa käytetään liukulujakolaskuja ja laittamassasi C# -koodissa käytetään kokonaislukujakolaskuja.

En usko että Visual Studio tekisi noin alkeellista mokaa käännöksessä, joten oletan edelleen, että olet käyttänyt jotain viallista käännöstyökalua.

juffe [15.01.2020 18:07:26]

Kiitos nyt toimii.
Ihan siis käsin käänsin tuosta vb.netistä -> C# ja Visual studion perusasetuksilla buildasin.

Grez [16.01.2020 08:38:32]

juffe kirjoitti:

Kiitos nyt toimii.
Ihan siis käsin käänsin tuosta vb.netistä -> C#

Ok. Itse en lähtisi kääntämään käsin, koska kone kääntää tuhansia rivejä sekunnissa virheettömästi, niin tuntuu täysin järjettömältä ajankäytöltä.

juffe [16.01.2020 21:26:09]

Enpä tiennyt että on konekääntäjiä suoraan.
Tuohon samaan projektiin liittyy että pitäisi saada nyt vuorostaan C-kielestä käännettyä c# kieleen.
Ite koodi on tässä: https://github.com/databeredning/geoid/blob/master/geoid-hm.c
Koitin C++ to C# converterilla kääntää, mutta kompastuksena oli noi fopen, fscanf, fclose mitä ei converteri osannnut.

ilmeisesti kuitenkin FileStream fs = File.OpenRead pystyy aukomaan tiedoston. Mutta miten tuo fscanf?

Grez [17.01.2020 08:45:25]

Voisi hieman yksinkertaistaen sanoa että VB.Net ja C# ovat samat kielet, joita vaan kirjoitetaan eri tavalla, jolloin niille on helppo tehdä koneellinen kääntäjä joka osaa kääntää kaiken kieleltä toiselle.

C ja C# ovat hyvin erilaisia kieliä, joten niiden välille on huomattavasti vaikeampi tehdä siistiä jälkeä tekevä kääntäjä.

juffe [25.01.2020 22:56:24]

Miten mun pitäisi populoida tuo 2d taulukko nyt oikeaoppisesti?

kooodinpätkänä on nyt tämä, mutta ei vaan toimi:

var lines = File.ReadAllLines("SWEN08_RH2000.DAT");

Double[,] dem = new Double[801, 376];

for (int i = 0; i < 801;)
{
    var data = lines[i].Split(new[] { "  " }, StringSplitOptions.None).Select(c => Convert.ToDouble(c)).ToList();

    for (int j = 0; j < 801;)
        dem[i, j] = data[j];
}

Grez [26.01.2020 07:52:38]

Heti päältä sanoisin, että sulla on 801 x 376 kokoinen taulukko, mutta koetat lukea 801 x 801 tietuetta. LIsäksi et missään kasvata i:tä etkä j:tä, niin eihän tuo voi toimia.

Eli jos sun tiedostossa on sarakkeet erotettu kahdella(??) välilyönnillä ja rivit on erotettu .Netin oletuksena ymmärtämällä rivivaihdolla (kuten koodista voisi päätellä), niin sitten tämä voisi toimia:

var lines = File.ReadAllLines("SWEN08_RH2000.DAT");

var dem = new double[801, 376];

for (int i = 0; i < 801; i++)
{
    var data = lines[i].Split(new[] { "  " }, StringSplitOptions.None).Select(c => Convert.ToDouble(c)).ToList();

    for (int j = 0; j < 376; j++)
    {
        dem[i, j] = data[j];
    }
}

Tosin kun kerran joka tapauksessa käpistelet splitattuja osioita loopissa, niin siirtäisin ton merkkijonosta doubleksi konvertoimisen sinne looppiin.

var lines = File.ReadAllLines("SWEN08_RH2000.DAT");

var dem = new double[801, 376];

for (int i = 0; i < 801; i++)
{
    var data = lines[i].Split(new[] { "  " }, StringSplitOptions.None);

    for (int j = 0; j < 376; j++)
    {
        dem[i, j] = Convert.ToDouble(data[j]);
    }
}

Jos taas haluat käyttää LinQ-juttuja for-looppien asemesta ja sulle kelpaa double[,] asemesta double[][] niin

var dem = File.ReadAllLines("SWEN08_RH2000.DAT").Select(l=>
    l.Split(new[] { "  " }, StringSplitOptions.None).Select(c=>Convert.ToDouble(c)).ToArray()
    ).ToArray();

Sivun alkuun

Vastaus

Aihe on jo aika vanha, joten et voi enää vastata siihen.

Kirjautuminen

Haku

Tehtävät