.NET

[DimPrawn]

Re: Franco

a JAVA permie. Even worse. :rollin

It works like this. You write C#, VB.NET or any of the .NET compliant source code.

You compile it into an assembly (a dll or exe to you and me). The assembly contains MSIL a type of non-cpu specific machine language.

When you run the assembly, the JIT compiler converts the MSIL to native machine code on the fly (in memory), optimised for the CPU. This compilation occurs when the assembly is loaded into memory (so there is a small delay the 1st time it runs).

Now I know Java has JIT (hotspot) or something, but it can't be any good because it came from Sun Microsystems.

[SupremeSpod]

Re: Franco

The assembly contains MSIL a type of non-cpu specific machine language.

A little like 'C' then, eh?

[FrancoLondinium]

Re: Franco

"a JAVA permie. Even worse"

From next month, a .Net permie too.

Only until I can find a contract that pays me at least twice than what I get as a permie.

[DimPrawn]

Re: Franco

It looks like this coded by hand.

 .method private hidebysig instance 
           void DrawMandelbrot(class [System.Drawing]System.Drawing.Graphics g,
                               float32 fpMandelWidth, int32 ipIterations) cil managed {

    .locals (
    [0] float32 x, // Complex Real portion
    [1] float32 y, // Complex Imaginary portion
    [2] float32 fpGranularity, // Resolution of image on screen
    [3] int32 ipPixelX, // X position on screen
    [4] int32 ipPixelY, // Y position on screen
    // Escape Velocity locals
    [5] float32 fpX,
    [6] float32 fpY,
    [7] float32 fpXTemp,
    [8] float32 fpYTemp,
    [9] float32 fpX2, // X Squared
    [10] float32 fpY2, // Y Squared
    [11] int32 i // Loop variable used to calc escape velocity
    )
    // Calculate Granularity
    ldc.r4 4
    ldarg fpMandelWidth
    div
    stloc fpGranularity


    // Initialise point on screen
    ldc.i4.0
    dup
    stloc ipPixelX
    stloc ipPixelY


    // Start the real portion off
    ldc.r4 -2.5
    stloc x

NextReal:

    // Start the imaginary portion off
    ldc.r4 -1.5
    stloc y

NextImaginary:

    // Calculate Escape Velocity

    // Initialise locals
    ldloc x
    stloc fpX

    ldloc y
    stloc fpY

    ldloc x
    dup
    mul
    stloc fpX2

    ldloc y
    dup
    mul
    stloc fpY2


    // Initialise i
    ldc.i4.0
    stloc i
NextIteration:


    ldloc x
    ldloc fpX2
    ldloc fpY2
    sub
    add
    stloc fpXTemp

    ldloc y
    ldloc fpY
    ldloc fpX
    ldc.r4 2
    mul
    mul
    add
    stloc fpYTemp

    // Calculate X squared
    ldloc fpXTemp
    dup
    mul
    stloc fpX2

    // Calculate Y squared
    ldloc fpYTemp
    dup
    mul
    stloc fpY2

    // If X Squared plus Y Squared is greater than 4, then we are guaranteed 
    // divergence to Infinity
    ldloc fpX2
    ldloc fpY2
    add
    ldc.r4 4
    bge Divergence

    // The previous values in the sequence become the current values in the sequence
    ldloc fpXTemp
    stloc fpX
    ldloc fpYTemp
    stloc fpY


    // Incrememt i
    ldc.i4.1
    ldloc i
    add
    stloc i

    ldloc i
    ldarg ipIterations
    blt NextIteration // Assume convergence to zero if we reach our iteration limit

Divergence:

    // Draw Pixel. i is now the escape velocity

    // Load the Graphics context
    ldarg g

    // Calculate the color based on the escape velocity


    ldarg ipIterations
    ldloc i
    sub
    stloc i

    // Red
    ldloc i
    ldc.i4 12
    mul
    ldc.i4 256
    rem

    // Green
    ldloc i
    ldc.i4 16
    mul
    ldc.i4 256
    rem

    // Blue
    ldloc i
    ldc.i4 5
    mul
    ldc.i4 256
    rem

    call value class [System.Drawing]System.Drawing.Color 
                           [System.Drawing]System.Drawing.Color::FromArgb(int32,
                                                                          int32,
                                                                          int32)


    // Create a new Pen on the stack
    ldc.r4 1
    newobj instance void [System.Drawing]System.Drawing.Pen::.ctor(value class 
                                              [System.Drawing]System.Drawing.Color,
                                                float32)

    // Load the coords of the point to draw
    ldloc ipPixelX
    ldloc ipPixelY

    // Width and Height
    ldc.i4.2
    dup

    call instance void [System.Drawing]System.Drawing.Graphics::DrawRectangle(class 
                                               [System.Drawing]System.Drawing.Pen,
                                                int32,
                                                int32,
                                                int32,
                                                int32)

    // Next PixelY
    ldc.i4.1
    ldloc ipPixelY
    add
    stloc ipPixelY

    // Advance through the imaginary portion
    ldloc y
    ldloc fpGranularity
    add
    stloc y

    ldloc y
    ldc.r4 1.5
    blt NextImaginary

    // Advance through ipPixelX
    ldc.i4.1
    ldloc ipPixelX
    add
    stloc ipPixelX

    // Start at the top of the screen for the next column
    ldc.i4.0
    stloc ipPixelY

    // Advance through the real portion
    ldloc x
    ldloc fpGranularity
    add
    stloc x

    ldloc x
    ldc.r4 1.5
    blt NextReal

    ret
} // method

[SupremeSpod]

Re: Franco

DP, thanks, like it!

So, why aren't people coding it by hand then?

I've got a .net environment for my 'phone, must have a play...

[DimPrawn]

Re: Franco

Well, you can of course code directly in MSIL rather than say C#.

But, apart from making you look quite hard, why would want to?

If you are interested msdn.microsoft.com/msdnmag/issues/01/05/bugslayer/print.asp

[SupremeSpod]

Re: Franco

But, apart from making you look quite hard, why would want to?

Wrong, it doesn't make me look hard, I'm a geek, it makes me hard!!!

As for a reason, maybe for the same reason I like to run Linux on my iPaq.

[FrancoLondinium]

Re:.

"But, apart from making you look quite hard, why would want to?"

Might provoke an erection.

[threaded]

Re: Franco

Here's a Mandelbrot done in Forth. much easier to understand and considerably shorter.

hex 4666 dup negate do i 4000 dup 2* negate do 2a 0 dup 2dup 1e 0 do 2swap * d >>a 4 pick + -rot - j + dup dup * e >>a rot dup dup * e >>a rot swap 2dup + 10000 > if 3drop 2drop 20 0 dup 2dup leave then loop 2drop 2drop type 268 +loop cr drop 5de +loop

[DimPrawn]

Re: Franco

That's great threaded, but does it display this?



No, didn't think so. :\