Eigentlich bin ich ja ein grosser Fan von VB.net... nach dem hier nicht mehr so:

c# code:

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

using System;   class SpectralNorm {    public static void Main(String[] args) {       int n = 5000;       if (args.Length > 0) n = Int32.Parse(args[0]);         Console.WriteLine("{0:f9}", new SpectralNorm().Approximate(n));    }        double Approximate(int n) {       // create unit vector       double[] u = new double[5000];       for (int i=0; i<n; i++) u[i] =  1;         // 20 steps of the power method       double[] v = new double[5000];       for (int i=0; i<n; i++) v[i] = 0;         for (int i=0; i<10; i++) {          MultiplyAtAv(ref n, ref u, ref v);          MultiplyAtAv(ref n, ref v, ref u);       }         // B=AtA         A multiplied by A transposed       // v.Bv /(v.v)   eigenvalue of v       double vBv = 0, vv = 0;       for (int i=0; i<n; i++) {          vBv += u[i]*v[i];          vv  += v[i]*v[i];       }         return Math.Sqrt(vBv/vv);    }        /* return element i,j of infinite matrix A */    double A(ref int i, ref int j){       return 1.0/((i+j)*(i+j+1)/2 +i+1);    }      /* multiply vector v by matrix A */    void MultiplyAv(ref int n, ref double[] v, ref double[] Av){       for (int i=0; i<n; i++){          Av[i] = 0;          for (int j=0; j<n; j++) Av[i] += A(ref i, ref j)*v[j];       }    }      /* multiply vector v by matrix A transposed */    void MultiplyAtv(ref int n, ref double[] v, ref double[] Atv){       for (int i=0;i<n;i++){          Atv[i] = 0;          for (int j=0; j<n; j++) Atv[i] += A(ref j,ref i)*v[j];       }    }      /* multiply vector v by matrix A and then by matrix A transposed */    void MultiplyAtAv(ref int n, ref double[] v, ref double[] AtAv){       double[] u = new double[5000];       MultiplyAv(ref n, ref v, ref u);       MultiplyAtv(ref n, ref u, ref AtAv);    }     }

vb.net:

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

Option Strict On Imports System Class SpectralNorm     Public Shared Sub Main(ByVal args As String())         Dim n As Integer = 5000         If args.Length > 0 Then             n = Int32.Parse(args(0))         End If         Console.WriteLine("{0:f9}", New SpectralNorm().Approximate(n))     End Sub     Private Function Approximate(ByVal n As Integer) As Double         ' create unit vector         dim u(5000) as Double         For i As Integer = 0 To n - 1             u(i) = 1         Next         ' 20 steps of the power method         dim v(5000) as Double         For i As Integer = 0 To n - 1             v(i) = 0         Next         For i As Integer = 0 To 9             MultiplyAtAv(n, u, v)             MultiplyAtAv(n, v, u)         Next         ' B=AtA         A multiplied by A transposed         ' v.Bv /(v.v)   eigenvalue of v         Dim vBv As Double = 0, vv As Double = 0         For i As Integer = 0 To n - 1             vBv += u(i) * v(i)             vv += v(i) * v(i)         Next         Return Math.Sqrt(vBv / vv)     End Function     ' return element i,j of infinite matrix A     Private Function A(ByRef i As Integer, ByRef j As Integer) As Double         Return 1 / ((i + j) * (i + j + 1) / 2 + i + 1)     End Function     ' multiply vector v by matrix A     Private Sub MultiplyAv(ByRef n As Integer, ByRef v As Double(), ByRef Av As Double())         For i As Integer = 0 To n - 1             Av(i) = 0             For j As Integer = 0 To n - 1                 Av(i) += A(i, j) * v(j)             Next         Next     End Sub     ' multiply vector v by matrix A transposed     Private Sub MultiplyAtv(ByRef n As Integer, ByRef v As Double(), ByRef Atv As Double())         For i As Integer = 0 To n - 1             Atv(i) = 0             For j As Integer = 0 To n - 1                 Atv(i) += A(j, i) * v(j)             Next         Next     End Sub     ' multiply vector v by matrix A and then by matrix A transposed     Private Sub MultiplyAtAv(ByRef n As Integer, ByRef v As Double(), ByRef AtAv As Double())         dim u(5000) as Double         MultiplyAv(n, v, u)         MultiplyAtv(n, u, AtAv)     End Sub End Class

Kommt vom Computer Language shootout. Probierts mal aus! Bei mir ist C# echt etwa 50 % schneller!! EDIT: Sorry, sogar 100%! mit n==1000 komme ich bei c# auf 703 MS, während es vb.net in lächerlichen 1530 ms schafft. Das ist grauenhaft!

Beide Versionen im Release-Modus?
Beide Versionen identisch und 100%ig optimiert?

Dann müssten beide Compiler eigtl. gleich gute Ergebnisse liefern.... sehr komisch

100 % optimiert und Release, beide. Es ist tragisch. Armes VB.net.

EDIT: Ausser ich hab nen gröberen Bock drin, aber ich seh' keinen!

EDIT: Wow, da war noch ein "unsafe" drin. Macht aber null Unterschied. Die Performance-Differenz bleibt extrem.
Zur Bemerkung: Es werden sehr viele Funktionsaufrufe getätigt, wie in einem PC-Spiel oä. Da scheint der VB-Compiler grausam Performance zu verschenken.

Hallo,

vielleicht bringen die Kommentare des Blogeintrags „Performance of C# vs. VB.NET“ von James Crowley etwas Licht in's Dunkel.

Grüße,
Matthias