Sayısal hesaplama

Spektral norm

Sonsuz bir matrisin 300 × 300'lük kesitinin spektral normu kuvvet yöntemiyle, 10 yinelemede hesaplanır. Ondalık bölmeyi, sık çağrılan küçük işlevleri ve liste okumayı ölçer.

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

Canlı ölçüm

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

Spektral norm 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ç

Spektral norm

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

300 × 300 matris, 10 yineleme · ondalık bölme ve küçük işlevler. Çubuk uzunsa daha hızlı.

DilReferans

KabaLang

3,6 ms

C++

4,3 msKabaLang 1,20 kat hızlı

Python

379 msKabaLang 104 kat hızlı

Dil	En iyi	Ortalama	Derleme	İkili boyutu
KabaLang	3,6 ms	3,8 ms	857 ms	1.000 KB
C++	4,3 ms	5,1 ms	351 ms	16 KB
Python	379 ms	385 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?

Ondalık bölmeyi, sık çağrılan küçük işlevleri ve liste okumayı ö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

1.274223986

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

fonksiyon a(i: sayi, j: sayi) -> ondalik:
    don 1.0 / ondalik((i + j) * (i + j + 1) // 2 + i + 1)

fonksiyon a_carp(u: liste<ondalik>) -> liste<ondalik>:
    n = u.uzunluk()
    v = [0.0] * n
    dongu i icinde 0..<n:
        t = 0.0
        dongu j icinde 0..<n:
            t += a(i, j) * u[j]
        v[i] = t
    don v

fonksiyon at_carp(u: liste<ondalik>) -> liste<ondalik>:
    n = u.uzunluk()
    v = [0.0] * n
    dongu i icinde 0..<n:
        t = 0.0
        dongu j icinde 0..<n:
            t += a(j, i) * u[j]
        v[i] = t
    don v

fonksiyon ata_carp(u: liste<ondalik>) -> liste<ondalik>:
    don at_carp(a_carp(u))

n = 300
u = [1.0] * n
v = [0.0] * n
dongu _ icinde 0..<10:
    v = ata_carp(u)
    u = ata_carp(v)

vbv = 0.0
vv = 0.0
dongu i icinde 0..<n:
    vbv += u[i] * v[i]
    vv += v[i] * v[i]
yazdir(f"{matematik.karekok(vbv / vv):.9f}")

program.cpp

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

double a(int i, int j) {
    return 1.0 / ((i + j) * (i + j + 1) / 2 + i + 1);
}

std::vector<double> a_carp(const std::vector<double> &u) {
    int n = u.size();
    std::vector<double> v(n);
    for (int i = 0; i < n; ++i) {
        double t = 0.0;
        for (int j = 0; j < n; ++j) t += a(i, j) * u[j];
        v[i] = t;
    }
    return v;
}

std::vector<double> at_carp(const std::vector<double> &u) {
    int n = u.size();
    std::vector<double> v(n);
    for (int i = 0; i < n; ++i) {
        double t = 0.0;
        for (int j = 0; j < n; ++j) t += a(j, i) * u[j];
        v[i] = t;
    }
    return v;
}

std::vector<double> ata_carp(const std::vector<double> &u) {
    return at_carp(a_carp(u));
}

int main() {
    const int n = 300;
    std::vector<double> u(n, 1.0), v;
    for (int k = 0; k < 10; ++k) {
        v = ata_carp(u);
        u = ata_carp(v);
    }
    double vbv = 0.0, vv = 0.0;
    for (int i = 0; i < n; ++i) {
        vbv += u[i] * v[i];
        vv += v[i] * v[i];
    }
    std::printf("%.9f\n", std::sqrt(vbv / vv));
    return 0;
}

program.py

import math


def a(i, j):
    return 1.0 / ((i + j) * (i + j + 1) // 2 + i + 1)


def a_carp(u):
    n = len(u)
    return [sum(a(i, j) * u[j] for j in range(n)) for i in range(n)]


def at_carp(u):
    n = len(u)
    return [sum(a(j, i) * u[j] for j in range(n)) for i in range(n)]


def ata_carp(u):
    return at_carp(a_carp(u))


n = 300
u = [1.0] * n
for _ in range(10):
    v = ata_carp(u)
    u = ata_carp(v)

vbv = 0.0
vv = 0.0
for i in range(n):
    vbv += u[i] * v[i]
    vv += v[i] * v[i]
print(f"{math.sqrt(vbv / vv):.9f}")

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

function a(i, j) {
  return 1.0 / ((i + j) * (i + j + 1) / 2 + i + 1);
}

function aCarp(u) {
  const n = u.length;
  const v = new Array(n);
  for (let i = 0; i < n; i++) {
    let t = 0.0;
    for (let j = 0; j < n; j++) t += a(i, j) * u[j];
    v[i] = t;
  }
  return v;
}

function atCarp(u) {
  const n = u.length;
  const v = new Array(n);
  for (let i = 0; i < n; i++) {
    let t = 0.0;
    for (let j = 0; j < n; j++) t += a(j, i) * u[j];
    v[i] = t;
  }
  return v;
}

function ataCarp(u) {
  return atCarp(aCarp(u));
}

export default function program(yaz = console.log) {
  const n = 300;
  let u = new Array(n).fill(1.0);
  let v = u;
  for (let k = 0; k < 10; k++) {
    v = ataCarp(u);
    u = ataCarp(v);
  }
  let vbv = 0.0, vv = 0.0;
  for (let i = 0; i < n; i++) {
    vbv += u[i] * v[i];
    vv += v[i] * v[i];
  }
  yaz(Math.sqrt(vbv / vv).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();