n-body Eiffel SmartEiffel program | Computer Language Benchmarks Game

performance measurements

Each table row shows performance measurements for this Eiffel SmartEiffel program with a particular command-line input value N.

N	CPU secs	Memory KB	Code B
200,000	0.16	520	1465
2,000,000	1.50	520	1465
20,000,000	14.81	520	1465

Read the ↓ make, command line, and program output logs for more details.

n-body Eiffel SmartEiffel program source code

--
-- The Great Computer Language Shootout
-- http://shootout.alioth.debian.org/
--
-- Contributed by Arnaud Payement for Smart Eiffel
--

-- SPLITFILE=body.e
class BODY

creation {ANY}
   jupiter, saturn, uranus, neptune, sun

feature {ANY}
   pi: REAL is 3.141592653589793

   solar_mass: REAL is
      once
         Result := 4 * pi * pi
      end

   days_per_year: REAL is 365.24

   x: REAL

   y: REAL

   z: REAL

   vx: REAL

   vy: REAL

   vz: REAL

   mass: REAL

   set_x (a: REAL) is
      do
         x := a
      end

   set_y (a: REAL) is
      do
         y := a
      end

   set_z (a: REAL) is
      do
         z := a
      end

   set_vx (a: REAL) is
      do
         vx := a
      end

   set_vy (a: REAL) is
      do
         vy := a
      end

   set_vz (a: REAL) is
      do
         vz := a
      end

   jupiter is
      do
         x := 4.84143144246472090e+00
         y := -1.16032004402742839e+00
         z := -1.03622044471123109e-01
         vx := 1.66007664274403694e-03 * days_per_year
         vy := 7.69901118419740425e-03 * days_per_year
         vz := -6.90460016972063023e-05 * days_per_year
         mass := 9.54791938424326609e-04 * solar_mass
      end

   saturn is
      do
         x := 8.34336671824457987e+00
         y := 4.12479856412430479e+00
         z := -4.03523417114321381e-01
         vx := -2.76742510726862411e-03 * days_per_year
         vy := 4.99852801234917238e-03 * days_per_year
         vz := 2.30417297573763929e-05 * days_per_year
         mass := 2.85885980666130812e-04 * solar_mass
      end

   uranus is
      do
         x := 1.28943695621391310e+01
         y := -1.51111514016986312e+01
         z := -2.23307578892655734e-01
         vx := 2.96460137564761618e-03 * days_per_year
         vy := 2.37847173959480950e-03 * days_per_year
         vz := -2.96589568540237556e-05 * days_per_year
         mass := 4.36624404335156298e-05 * solar_mass
      end

   neptune is
      do
         x := 1.53796971148509165e+01
         y := -2.59193146099879641e+01
         z := 1.79258772950371181e-01
         vx := 2.68067772490389322e-03 * days_per_year
         vy := 1.62824170038242295e-03 * days_per_year
         vz := -9.51592254519715870e-05 * days_per_year
         mass := 5.15138902046611451e-05 * solar_mass
      end

   sun is
      do
         mass := solar_mass
      end

   offset_momentum (px: REAL; py: REAL; pz: REAL) is
      do
         vx := - px / solar_mass
         vy := - py / solar_mass
         vz := - pz / solar_mass
      end

end -- class BODY

-- SPLITFILE=nbody.e
class NBODY

insert ARGUMENTS

creation {ANY}
   make

feature {ANY}
   make is
      local
         n: INTEGER; i: INTEGER; bodies: NBODY_SYSTEM
      do
         create bodies.make
         std_output.put_real_format(bodies.energy,9)
         std_output.put_string("%N")
         n := argument(1).to_integer
         from
            i := 0
         until
            i = n
         loop
            bodies.advance(0.01)
            i := i + 1
         end
         std_output.put_real_format(bodies.energy,9)
         std_output.put_string("%N")
      end

end -- class NBODY
-- SPLITFILE=nbody_system.e
class NBODY_SYSTEM

creation {ANY}
   make

feature {ANY}
   bodies: FAST_ARRAY[BODY]

   make is
      local
         b: BODY; px: REAL; py: REAL; pz: REAL; i: INTEGER; bi : BODY
      do
         create bodies.make(5)
         create b.sun
         bodies.put(b, 0)
         create b.jupiter
         bodies.put(b, 1)
         create b.saturn
         bodies.put(b, 2)
         create b.uranus
         bodies.put(b, 3)
         create b.neptune
         bodies.put(b, 4)
         from
            i := 0
         until
            i = 5
         loop
            bi := bodies.item(i)
            px := px + bi.vx * bi.mass
            py := py + bi.vy * bi.mass
            pz := pz + bi.vz * bi.mass
            i := i + 1
         end
         bodies.item(0).offset_momentum(px, py, pz)
      end

   advance (dt: REAL) is
      local
         dx: REAL; dy: REAL; dz: REAL; distance: REAL; mag: REAL; i: INTEGER; j: INTEGER; bi: BODY; bj: BODY
      do
         from
            i := 0
         until
            i = 5
         loop
            bi := bodies.item(i)
            from
               j := i + 1
            until
               j = 5
            loop
               bj := bodies.item(j)
               dx := bi.x - bj.x
               dy := bi.y - bj.y
               dz := bi.z - bj.z
               distance := (dx * dx + dy * dy + dz * dz).sqrt
               mag := dt / (distance * distance * distance)
               bi.set_vx(bi.vx - dx * bj.mass * mag)
               bi.set_vy(bi.vy - dy * bj.mass * mag)
               bi.set_vz(bi.vz - dz * bj.mass * mag)
               bj.set_vx(bj.vx + dx * bi.mass * mag)
               bj.set_vy(bj.vy + dy * bi.mass * mag)
               bj.set_vz(bj.vz + dz * bi.mass * mag)
               j := j + 1
            end
            i := i + 1
         end
         from
            i := 0
         until
            i = 5
         loop
            bi := bodies.item(i)
            bi.set_x(bi.x + dt * bi.vx)
            bi.set_y(bi.y + dt * bi.vy)
            bi.set_z(bi.z + dt * bi.vz)
            i := i + 1
         end
      end

   energy: REAL is
      local
         dx: REAL; dy: REAL; dz: REAL; distance: REAL; e: REAL; i: INTEGER; j: INTEGER; bi: BODY; bj:BODY
      do
         from
            i := 0
         until
            i = 5
         loop
            bi := bodies.item(i)
            e := e + 0.5 * bi.mass * (bi.vx * bi.vx + bi.vy * bi.vy + bi.vz * bi.vz)
            from
               j := i + 1
            until
               j = 5
            loop
               bj := bodies.item(j)
               dx := bi.x - bj.x
               dy := bi.y - bj.y
               dz := bi.z - bj.z
               distance := (dx * dx + dy * dy + dz * dz).sqrt
               e := e - bi.mass * bj.mass / distance
               j := j + 1
            end
            i := i + 1
         end
         Result := e
      end

end -- class NBODY_SYSTEM

notes

make, command-line, and program output logs

BUILD COMMANDS FOR: nbody.se

Thu Mar 13 14:48:11 PDT 2008

copying /home/dunham/gp4/shootout/bench/nbody/nbody.se to nbody.e
cp /home/dunham/gp4/shootout/bench/nbody/nbody.se nbody.e
../../../bin/split_file.bash /home/dunham/gp4/shootout/bench/nbody/nbody.se nbody.e
splitfile  body.e
splitfile  nbody.e
splitfile  nbody_system.e
rm -f nbody.se_run
/opt/SmartEiffel/bin/se c -clean -boost -no_split -O3 -fomit-frame-pointer -march=pentium4 -mfpmath=sse -msse2   -o nbody.se_run nbody
rm nbody.e

=================================================================
COMMAND LINE (%A is single numeric argument):

nbody.se_run %A


PROGRAM OUTPUT
==============
-0.169075164
-0.169031665

OUT-OF-DATE! Read http://shootout.alioth.debian.org/

performance measurements

n-body Eiffel SmartEiffel program source code

notes

make, command-line, and program output logs