RunTimePerformance: cobra_nbody.cobra

# The Computer Language Benchmarks Game
# http://shootout.alioth.debian.org/
#
# originally by Kevin Carson
# modified by Tupteq, Fredrik Johansson, and Daniel Nanz
# modified by Maciej Fijalkowski
# 2to3
@number float
class Triple
    var x as float 
    var y as float 
    var z as float
    #pro x from var as float 
    #pro y from var as float 
    #pro z from var as float
    get squared as float
        return .x*.x + .y*.y + .z*.z
    
    cue init(x as float, y as float, z as float)
        base.init
        .x = x
        .y = y
        .z = z
        
    def toString as String is override
        return "\[[.x], [.y], [.z]\]"

class Body
    var coord as Triple
    var velocity as Triple
    var mass as float
    #pro coord from var as Triple
    #pro velocity from var as Triple
    #pro mass from var as float
    
    cue init(coord as Triple, velocity as Triple, mass as float)
        base.init
        .coord = coord
        .velocity = velocity
        .mass = mass  

    def updateCoordinates(dt as float)
        .coord.x += dt * .velocity.x
        .coord.y += dt * .velocity.y
        .coord.z += dt * .velocity.z

        
class BodyPair
    var body1 as Body
    var body2 as Body  
    #pro body1 from var as Body
    #pro body2 from var as Body  
    
    cue init(body1 as Body, body2 as Body)
        base.init
        .body1 = body1
        .body2 = body2

class Program
    def combinations(l) as List<of BodyPair>
        result = List<of BodyPair>()
        for x in l.count - 1
            ls = l[x+1:]
            for y in ls
                result.add(BodyPair(l[x],y))
        return result

    cue init
        base.init
    
        bodies as Dictionary<of String, Body> = {
            'sun': Body(Triple(0.0, 0.0, 0.0), Triple(0.0, 0.0, 0.0), .sOLAR_MASS),

            'jupiter': Body(Triple(4.84143144246472090,
                -1.16032004402742839,
                -0.103622044471123109),
                Triple(0.00166007664274403694 * .dAYS_PER_YEAR,
                0.00769901118419740425 * .dAYS_PER_YEAR,
                -0.0000690460016972063023 * .dAYS_PER_YEAR),
                0.000954791938424326609 * .sOLAR_MASS),

            'saturn': Body(Triple(8.34336671824457987,
                4.12479856412430479,
                -0.403523417114321381),
                Triple(-0.00276742510726862411 * .dAYS_PER_YEAR,
                0.00499852801234917238 * .dAYS_PER_YEAR,
                0.0000230417297573763929 * .dAYS_PER_YEAR),
                0.000285885980666130812 * .sOLAR_MASS),

            'uranus': Body(Triple(12.8943695621391310,
                -15.1111514016986312,
                -0.223307578892655734),
                Triple(0.00296460137564761618* .dAYS_PER_YEAR,
                0.00237847173959480950* .dAYS_PER_YEAR,
                -0.0000296589568540237556* .dAYS_PER_YEAR),
                0.0000436624404335156298* .sOLAR_MASS),

            'neptune': Body(Triple(15.3796971148509165,
                -25.9193146099879641,
                0.179258772950371181),
                Triple(0.00268067772490389322* .dAYS_PER_YEAR,
                0.00162824170038242295* .dAYS_PER_YEAR,
                -0.0000951592254519715870* .dAYS_PER_YEAR),
                0.0000515138902046611451* .sOLAR_MASS) 
        }
        .sYSTEM = List<of Body>()
        .sYSTEM.add(bodies['sun'])
        .sYSTEM.add(bodies['jupiter'])
        .sYSTEM.add(bodies['saturn'])
        .sYSTEM.add(bodies['uranus'])
        .sYSTEM.add(bodies['neptune'])
        .pAIRS = .combinations(.sYSTEM)
    var sYSTEM as List<of Body>
    var sOLAR_MASS as float = 4 * 3.14159265358979323 *  3.14159265358979323
    var dAYS_PER_YEAR as float = 365.24

    var pAIRS as List<of BodyPair>


    def advance(dt as float, n as int)
        bodies=.sYSTEM
        pairs=.pAIRS
        b1 as Body = bodies[0]
        b2 as Body = bodies[0]
        v1 as Triple = b1.velocity
        v2 as Triple = b2.velocity
        dx as float
        dy as float
        dz as float
        mag as float

        for i in n
            for p as BodyPair in pairs
                b1 = p.body1
                b2 = p.body2
                v1, v2 =b1.velocity, b2.velocity
                dx = b1.coord.x - b2.coord.x
                dy = b1.coord.y - b2.coord.y
                dz = b1.coord.z - b2.coord.z
                mag = dt * (Math.pow(dx * dx + dy * dy + dz * dz, -1.5f) )
                b1m as float= b1.mass * mag
                b2m as float = b2.mass * mag
                v1.x = v1.x - dx * b2m
                v1.y = v1.y - dy * b2m
                v1.z = v1.z - dz * b2m
                v2.x = v2.x + dx * b1m
                v2.y = v2.y + dy * b1m
                v2.z = v2.z + dz * b1m
            for b as Body in bodies
                b.updateCoordinates(dt)


    def report_energy
        bodies=.sYSTEM
        pairs=.pAIRS
        #print "Bodies Count:[bodies.count]\nPairs Count:[pairs.count]"
        e as float=0.0
        for p as BodyPair in pairs
            b1 as Body = p.body1
            b2 as Body = p.body2
            m = b1.mass * b2.mass
            #print m
            dx = b1.coord.x - b2.coord.x
            dy = b1.coord.y - b2.coord.y
            dz = b1.coord.z - b2.coord.z
            sqrs = dx * dx + dy * dy + dz * dz 
            e -= m / Math.sqrt(sqrs ) 
        for b as Body in bodies
            e += b.mass * b.velocity.squared *0.5
        print e

    def offset_momentum(ref1 as Body)
        bodies=.sYSTEM
        px as float=0.0 
        py as float=0.0
        pz as float=0.0

        for b as Body in bodies
            m as float = b.mass
            px = px- b.velocity.x * m
            py = py-b.velocity.y * m
            pz = pz-b.velocity.z * m
        v, m = ref1.velocity, 1/ ref1.mass
        v.x = px * m
        v.y = py * m
        v.z = pz * m
        print v

    def main
        sw = System.Diagnostics.Stopwatch()
        sw.start
        .report_energy
        .offset_momentum( .sYSTEM[0]) #sun
        .report_energy
        .advance(0.01, 50000)
        .report_energy
        sw.stop
        print 'duration: [sw.elapsed] ms '