ഹലോ, വേൾഡ്! ഇതാണ് എന്റെ ആദ്യത്തെ പോസ്റ്റ്, ഈ വെബ്സൈറ്റിന്റെ പ്രവർത്തനക്ഷമത പരീക്ഷിക്കാൻ മാത്രമാണ് ഇത് ഉപയോഗിക്കുന്നത്.
ഇവിടെ ബാസൽ പ്രശ്നം കണക്കാക്കുന്ന വിവിധ ഭാഷകളിലെ കുറച്ച് കോഡ് സ്നിപ്പെറ്റുകൾ ഉണ്ട്:
തുടക്കത്തിൽ,
പൈത്തൺ
def pi_squared_over_6(N: int) -> float:
return sum(x**(-2) for x in range(1,N))
റസ്റ്റ്
fn pi_squared_over_6(N: u64) -> f64 {
(1..N).map(|x| 1.0 / ((x*x) as f64)).sum()
}
ഹാസ്കെൽ
piSquaredOver6 :: Integer -> Double
-- no capital N in Haskell :(
piSquaredOver6 n = sum $ map (\x -> 1 / fromIntegral (x * x)) [1..n]
സി
double pi_squared_over_6(unsigned int N) {
double sum = 0.0;
for (int i = 1; i < N; i++) {
sum += 1.0 / (i*i);
}
return sum;
}
നിങ്ങളുടെ പ്രിയപ്പെട്ട പരിഹാരം ഏതാണ്?
പ്രകടനം
ഒരു M1 Pro-ൽ -ന് അവ എങ്ങനെ പ്രകടനം കാണിക്കുന്നുവെന്ന് നോക്കാം.
ഭാഷ | സമയം (ms, ) |
---|---|
റസ്റ്റ് (സമാന്തരമായി) | |
റസ്റ്റ് (–release) | |
സി (-O3) | |
ഹാസ്കെൽ (-O3) | |
പൈത്തൺ (3.10) |
പൈത്തൺ പരിഹരിക്കുന്നു
പൈത്തൺ കോഡ് പ്രവർത്തിക്കാൻ വളരെയധികം സമയമെടുത്തു, അതിനാൽ numpy ഉപയോഗിച്ച് ഇത് പരിഹരിക്കാം, ഇത് വെക്റ്ററൈസ്ഡ് സി കോഡിലേക്ക് കോൾ ചെയ്യുന്നു.
import numpy as np
def pi_squared_over_6(N: int) -> float:
x = np.ones(N)
r = np.arange(1,N)
sq = np.square(r)
div = np.divide(x, sq)
return float(np.sum(div))
കുറച്ച് മെച്ചപ്പെട്ടു, പക്ഷേ ഞാൻ btm
പരിശോധിക്കുമ്പോൾ, അമിതമായ മെമ്മറി ഉപയോഗം സൂചിപ്പിക്കുന്നത് ബില്യൺ ഫ്ലോട്ടുകൾ ചലിപ്പിക്കുന്നതാണ് ഭൂരിഭാഗം ജോലിയും,
യഥാർത്ഥ ഗണിതമല്ല. ഇത് ചങ്കുകളായി വിഭജിച്ച് പരീക്ഷിക്കാം:
def pi_squared_over_6(N: int) -> float:
CHUNKS = 25000
SIZE = N // CHUNKS
s = 0.0
x = np.ones(N // CHUNKS - 1)
for i in range(CHUNKS):
N_tmp = i * SIZE
r = np.arange(N_tmp + 1, N_tmp + SIZE)
sq = np.square(r)
div = np.divide(x, sq)
s += np.sum(div)
# മെമ്മറി ഡീലോക്കേറ്റ് ചെയ്യുക
del sq
del div
del r
return s
വളരെ മെച്ചം! ഇപ്പോൾ ഇത് 2 സെക്കൻഡിനുള്ളിൽ പ്രവർത്തിക്കുന്നു!