Sayısal hesaplama

N-cisim

Güneş ve dört dev gezegenin 100.000 adımlık yörünge benzetimi; başta ve sonda toplam enerji yazılır. Yapı alanlarına erişimi, karekökü ve ondalık sayı işlemlerini ölçer.

Bu sayfayı KabaLang ile yazılmış sunucu sundu.

Canlı ölçüm

Bu testi kendi bilgisayarınızda ölçün

N-cisim tarayıcınızda, WebAssembly ile koşar: KabaLang, C++, JavaScript ve Python. Ölçüm sayfası bu testi seçili açar; sonuçlar cihazınızda kalır.

Bu testi canlı ölç

N-cisim

C++'tan 1,04 kat hızlı

5 gezegen, 100.000 adım · yapı alanları ve ondalık sayı. Çubuk uzunsa daha hızlı.

DilReferans

KabaLang

4,8 ms

C++

5,0 msKabaLang 1,04 kat hızlı

Python

357 msKabaLang 75 kat hızlı

Dil	En iyi	Ortalama	Derleme	İkili boyutu
KabaLang	4,8 ms	5,8 ms	790 ms	1.004 KB
C++	5,0 ms	5,4 ms	335 ms	16 KB
Python	357 ms	364 ms	–	–

Referans ölçüm: 21 Ekim 2026 14:53 · 11th Gen Intel(R) Core(TM) i7-11370H @ 3.30GHz · KabaLang 0.6.0 (94109b3+) · süreler milisaniye; ısınma koşusundan sonra 10 koşunun en iyisi.

Bu testte KabaLang / C++ oranı, zaman içinde

Ne ölçüyor?

Yapı alanlarına erişimi, karekökü ve ondalık sayı işlemlerini ölçer.

Kategori: Sayısal hesaplama. Tam sayı ve ondalık aritmetik, sıkı döngüler, işlev çağrıları. Üç program da aynı algoritmayı aynı adımlarla uygular ve aynı çıktıyı üretmek zorundadır; çıktı tutmazsa ölçüm geçersiz sayılır.

Beklenen çıktı

stdout

-0.169075164
-0.169079859

Derleme

Komutlar ve bayraklar

KabaLang

Uçbirim

kabalang derle program.kbl -o program
./program

C++

Uçbirim

clang++ -O2 -o program program.cpp
./program

Python

Uçbirim

python3 program.py

KabaLang: ek bayrak yok. Varsayılan eniyileme düzeyi -O 2; program, çalışma zamanıyla birlikte bağlama anında eniyilenir ve statik bağlanır (tek, bağımlılıksız ikili).
C++: -O2; standart kütüphaneye dinamik bağlı.
Python: standart yorumlayıcı, ek modül yok.

Kaynak

Ölçülen programlar

Aşağıdaki dosyalar ölçülen programların kendisidir.

program.kbl

PI = 3.141592653589793
GUNES_KUTLESI = 4.0 * PI * PI
GUN = 365.24

yapi Govde:
    x: ondalik = 0.0
    y: ondalik = 0.0
    z: ondalik = 0.0
    vx: ondalik = 0.0
    vy: ondalik = 0.0
    vz: ondalik = 0.0
    kutle: ondalik = 0.0

fonksiyon govde(x: ondalik, y: ondalik, z: ondalik, vx: ondalik, vy: ondalik, vz: ondalik, kutle: ondalik) -> Govde:
    don Govde(x = x, y = y, z = z, vx = vx * GUN, vy = vy * GUN, vz = vz * GUN, kutle = kutle * GUNES_KUTLESI)

fonksiyon ilerle(degisir govdeler: liste<Govde>, dt: ondalik):
    n = govdeler.uzunluk()
    dongu i icinde 0..<n:
        dongu j icinde (i + 1)..<n:
            dx = govdeler[i].x - govdeler[j].x
            dy = govdeler[i].y - govdeler[j].y
            dz = govdeler[i].z - govdeler[j].z
            d2 = dx * dx + dy * dy + dz * dz
            buyukluk = dt / (d2 * matematik.karekok(d2))
            govdeler[i].vx -= dx * govdeler[j].kutle * buyukluk
            govdeler[i].vy -= dy * govdeler[j].kutle * buyukluk
            govdeler[i].vz -= dz * govdeler[j].kutle * buyukluk
            govdeler[j].vx += dx * govdeler[i].kutle * buyukluk
            govdeler[j].vy += dy * govdeler[i].kutle * buyukluk
            govdeler[j].vz += dz * govdeler[i].kutle * buyukluk
    dongu i icinde 0..<n:
        govdeler[i].x += dt * govdeler[i].vx
        govdeler[i].y += dt * govdeler[i].vy
        govdeler[i].z += dt * govdeler[i].vz

fonksiyon enerji(govdeler: liste<Govde>) -> ondalik:
    e = 0.0
    n = govdeler.uzunluk()
    dongu i icinde 0..<n:
        a = govdeler[i]
        e += 0.5 * a.kutle * (a.vx * a.vx + a.vy * a.vy + a.vz * a.vz)
        dongu j icinde (i + 1)..<n:
            b = govdeler[j]
            dx = a.x - b.x
            dy = a.y - b.y
            dz = a.z - b.z
            e -= a.kutle * b.kutle / matematik.karekok(dx * dx + dy * dy + dz * dz)
    don e

fonksiyon momentum_dengele(degisir govdeler: liste<Govde>):
    px = 0.0
    py = 0.0
    pz = 0.0
    dongu g icinde govdeler:
        px += g.vx * g.kutle
        py += g.vy * g.kutle
        pz += g.vz * g.kutle
    govdeler[0].vx = -px / GUNES_KUTLESI
    govdeler[0].vy = -py / GUNES_KUTLESI
    govdeler[0].vz = -pz / GUNES_KUTLESI

govdeler = [
    govde(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0),
    govde(4.84143144246472090e+00, -1.16032004402742839e+00, -1.03622044471123109e-01,
          1.66007664274403694e-03, 7.69901118419740425e-03, -6.90460016972063023e-05, 9.54791938424326609e-04),
    govde(8.34336671824457987e+00, 4.12479856412430479e+00, -4.03523417114321381e-01,
          -2.76742510726862411e-03, 4.99852801234917238e-03, 2.30417297573763929e-05, 2.85885980666130812e-04),
    govde(1.28943695621391310e+01, -1.51111514016986312e+01, -2.23307578892655734e-01,
          2.96460137564761618e-03, 2.37847173959480950e-03, -2.96589568540237556e-05, 4.36624404335156298e-05),
    govde(1.53796971148509165e+01, -2.59193146099879641e+01, 1.79258772950371181e-01,
          2.68067772490389322e-03, 1.62824170038242295e-03, -9.51592254519715870e-05, 5.15138902046611451e-05),
]

momentum_dengele(&govdeler)
yazdir(f"{enerji(govdeler):.9f}")
dongu _ icinde 0..<100000:
    ilerle(&govdeler, 0.01)
yazdir(f"{enerji(govdeler):.9f}")

program.cpp

#include <cmath>
#include <cstdio>
#include <vector>

const double PI = 3.141592653589793;
const double GUNES_KUTLESI = 4 * PI * PI;
const double GUN = 365.24;

struct Govde {
    double x, y, z, vx, vy, vz, kutle;
};

Govde govde(double x, double y, double z, double vx, double vy, double vz, double kutle) {
    return Govde{x, y, z, vx * GUN, vy * GUN, vz * GUN, kutle * GUNES_KUTLESI};
}

void ilerle(std::vector<Govde> &govdeler, double dt) {
    size_t n = govdeler.size();
    for (size_t i = 0; i < n; ++i) {
        Govde &a = govdeler[i];
        for (size_t j = i + 1; j < n; ++j) {
            Govde &b = govdeler[j];
            double dx = a.x - b.x;
            double dy = a.y - b.y;
            double dz = a.z - b.z;
            double d2 = dx * dx + dy * dy + dz * dz;
            double buyukluk = dt / (d2 * std::sqrt(d2));
            a.vx -= dx * b.kutle * buyukluk;
            a.vy -= dy * b.kutle * buyukluk;
            a.vz -= dz * b.kutle * buyukluk;
            b.vx += dx * a.kutle * buyukluk;
            b.vy += dy * a.kutle * buyukluk;
            b.vz += dz * a.kutle * buyukluk;
        }
    }
    for (Govde &g : govdeler) {
        g.x += dt * g.vx;
        g.y += dt * g.vy;
        g.z += dt * g.vz;
    }
}

double enerji(const std::vector<Govde> &govdeler) {
    double e = 0.0;
    size_t n = govdeler.size();
    for (size_t i = 0; i < n; ++i) {
        const Govde &a = govdeler[i];
        e += 0.5 * a.kutle * (a.vx * a.vx + a.vy * a.vy + a.vz * a.vz);
        for (size_t j = i + 1; j < n; ++j) {
            const Govde &b = govdeler[j];
            double dx = a.x - b.x;
            double dy = a.y - b.y;
            double dz = a.z - b.z;
            e -= a.kutle * b.kutle / std::sqrt(dx * dx + dy * dy + dz * dz);
        }
    }
    return e;
}

void momentum_dengele(std::vector<Govde> &govdeler) {
    double px = 0.0, py = 0.0, pz = 0.0;
    for (const Govde &g : govdeler) {
        px += g.vx * g.kutle;
        py += g.vy * g.kutle;
        pz += g.vz * g.kutle;
    }
    govdeler[0].vx = -px / GUNES_KUTLESI;
    govdeler[0].vy = -py / GUNES_KUTLESI;
    govdeler[0].vz = -pz / GUNES_KUTLESI;
}

int main() {
    std::vector<Govde> govdeler = {
        govde(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0),
        govde(4.84143144246472090e+00, -1.16032004402742839e+00, -1.03622044471123109e-01,
              1.66007664274403694e-03, 7.69901118419740425e-03, -6.90460016972063023e-05, 9.54791938424326609e-04),
        govde(8.34336671824457987e+00, 4.12479856412430479e+00, -4.03523417114321381e-01,
              -2.76742510726862411e-03, 4.99852801234917238e-03, 2.30417297573763929e-05, 2.85885980666130812e-04),
        govde(1.28943695621391310e+01, -1.51111514016986312e+01, -2.23307578892655734e-01,
              2.96460137564761618e-03, 2.37847173959480950e-03, -2.96589568540237556e-05, 4.36624404335156298e-05),
        govde(1.53796971148509165e+01, -2.59193146099879641e+01, 1.79258772950371181e-01,
              2.68067772490389322e-03, 1.62824170038242295e-03, -9.51592254519715870e-05, 5.15138902046611451e-05),
    };

    momentum_dengele(govdeler);
    std::printf("%.9f\n", enerji(govdeler));
    for (int i = 0; i < 100000; ++i) ilerle(govdeler, 0.01);
    std::printf("%.9f\n", enerji(govdeler));
    return 0;
}

program.py

import math

PI = 3.141592653589793
GUNES_KUTLESI = 4 * PI * PI
GUN = 365.24


class Govde:
    def __init__(self, x, y, z, vx, vy, vz, kutle):
        self.x, self.y, self.z = x, y, z
        self.vx, self.vy, self.vz = vx * GUN, vy * GUN, vz * GUN
        self.kutle = kutle * GUNES_KUTLESI


def ilerle(govdeler, dt):
    n = len(govdeler)
    for i in range(n):
        a = govdeler[i]
        for j in range(i + 1, n):
            b = govdeler[j]
            dx = a.x - b.x
            dy = a.y - b.y
            dz = a.z - b.z
            d2 = dx * dx + dy * dy + dz * dz
            buyukluk = dt / (d2 * math.sqrt(d2))
            a.vx -= dx * b.kutle * buyukluk
            a.vy -= dy * b.kutle * buyukluk
            a.vz -= dz * b.kutle * buyukluk
            b.vx += dx * a.kutle * buyukluk
            b.vy += dy * a.kutle * buyukluk
            b.vz += dz * a.kutle * buyukluk
    for g in govdeler:
        g.x += dt * g.vx
        g.y += dt * g.vy
        g.z += dt * g.vz


def enerji(govdeler):
    e = 0.0
    n = len(govdeler)
    for i in range(n):
        a = govdeler[i]
        e += 0.5 * a.kutle * (a.vx * a.vx + a.vy * a.vy + a.vz * a.vz)
        for j in range(i + 1, n):
            b = govdeler[j]
            dx = a.x - b.x
            dy = a.y - b.y
            dz = a.z - b.z
            e -= a.kutle * b.kutle / math.sqrt(dx * dx + dy * dy + dz * dz)
    return e


def momentum_dengele(govdeler):
    px = py = pz = 0.0
    for g in govdeler:
        px += g.vx * g.kutle
        py += g.vy * g.kutle
        pz += g.vz * g.kutle
    gunes = govdeler[0]
    gunes.vx = -px / GUNES_KUTLESI
    gunes.vy = -py / GUNES_KUTLESI
    gunes.vz = -pz / GUNES_KUTLESI


govdeler = [
    Govde(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0),
    Govde(4.84143144246472090e+00, -1.16032004402742839e+00, -1.03622044471123109e-01,
          1.66007664274403694e-03, 7.69901118419740425e-03, -6.90460016972063023e-05, 9.54791938424326609e-04),
    Govde(8.34336671824457987e+00, 4.12479856412430479e+00, -4.03523417114321381e-01,
          -2.76742510726862411e-03, 4.99852801234917238e-03, 2.30417297573763929e-05, 2.85885980666130812e-04),
    Govde(1.28943695621391310e+01, -1.51111514016986312e+01, -2.23307578892655734e-01,
          2.96460137564761618e-03, 2.37847173959480950e-03, -2.96589568540237556e-05, 4.36624404335156298e-05),
    Govde(1.53796971148509165e+01, -2.59193146099879641e+01, 1.79258772950371181e-01,
          2.68067772490389322e-03, 1.62824170038242295e-03, -9.51592254519715870e-05, 5.15138902046611451e-05),
]

momentum_dengele(govdeler)
print(f"{enerji(govdeler):.9f}")
for _ in range(100000):
    ilerle(govdeler, 0.01)
print(f"{enerji(govdeler):.9f}")

program.js · yalnız tarayıcı ölçümünde

const PI = 3.141592653589793;
const GUNES_KUTLESI = 4 * PI * PI;
const GUN = 365.24;

class Govde {
  constructor(x, y, z, vx, vy, vz, kutle) {
    this.x = x; this.y = y; this.z = z;
    this.vx = vx * GUN; this.vy = vy * GUN; this.vz = vz * GUN;
    this.kutle = kutle * GUNES_KUTLESI;
  }
}

function ilerle(govdeler, dt) {
  const n = govdeler.length;
  for (let i = 0; i < n; i++) {
    const a = govdeler[i];
    for (let j = i + 1; j < n; j++) {
      const b = govdeler[j];
      const dx = a.x - b.x, dy = a.y - b.y, dz = a.z - b.z;
      const d2 = dx * dx + dy * dy + dz * dz;
      const buyukluk = dt / (d2 * Math.sqrt(d2));
      a.vx -= dx * b.kutle * buyukluk;
      a.vy -= dy * b.kutle * buyukluk;
      a.vz -= dz * b.kutle * buyukluk;
      b.vx += dx * a.kutle * buyukluk;
      b.vy += dy * a.kutle * buyukluk;
      b.vz += dz * a.kutle * buyukluk;
    }
  }
  for (const g of govdeler) {
    g.x += dt * g.vx;
    g.y += dt * g.vy;
    g.z += dt * g.vz;
  }
}

function enerji(govdeler) {
  let e = 0.0;
  const n = govdeler.length;
  for (let i = 0; i < n; i++) {
    const a = govdeler[i];
    e += 0.5 * a.kutle * (a.vx * a.vx + a.vy * a.vy + a.vz * a.vz);
    for (let j = i + 1; j < n; j++) {
      const b = govdeler[j];
      const dx = a.x - b.x, dy = a.y - b.y, dz = a.z - b.z;
      e -= a.kutle * b.kutle / Math.sqrt(dx * dx + dy * dy + dz * dz);
    }
  }
  return e;
}

function momentumDengele(govdeler) {
  let px = 0.0, py = 0.0, pz = 0.0;
  for (const g of govdeler) {
    px += g.vx * g.kutle;
    py += g.vy * g.kutle;
    pz += g.vz * g.kutle;
  }
  const gunes = govdeler[0];
  gunes.vx = -px / GUNES_KUTLESI;
  gunes.vy = -py / GUNES_KUTLESI;
  gunes.vz = -pz / GUNES_KUTLESI;
}

export default function program(yaz = console.log) {
  const govdeler = [
    new Govde(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0),
    new Govde(4.84143144246472090e+00, -1.16032004402742839e+00, -1.03622044471123109e-01,
      1.66007664274403694e-03, 7.69901118419740425e-03, -6.90460016972063023e-05, 9.54791938424326609e-04),
    new Govde(8.34336671824457987e+00, 4.12479856412430479e+00, -4.03523417114321381e-01,
      -2.76742510726862411e-03, 4.99852801234917238e-03, 2.30417297573763929e-05, 2.85885980666130812e-04),
    new Govde(1.28943695621391310e+01, -1.51111514016986312e+01, -2.23307578892655734e-01,
      2.96460137564761618e-03, 2.37847173959480950e-03, -2.96589568540237556e-05, 4.36624404335156298e-05),
    new Govde(1.53796971148509165e+01, -2.59193146099879641e+01, 1.79258772950371181e-01,
      2.68067772490389322e-03, 1.62824170038242295e-03, -9.51592254519715870e-05, 5.15138902046611451e-05),
  ];
  momentumDengele(govdeler);
  yaz(enerji(govdeler).toFixed(9));
  for (let adim = 0; adim < 100000; adim++) ilerle(govdeler, 0.01);
  yaz(enerji(govdeler).toFixed(9));
}

// `node program.js` ile de koşar (tarayıcıda ölçüm işçisi program()ı çağırır).
if (globalThis.process?.argv?.[1]?.endsWith("program.js")) program();