Time a function: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
m (→{{header|RPL}}: TICKS instruction) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
| (6 intermediate revisions by 6 users not shown) | |||
Line 833:
=={{header|C++}}==
===Using <code>ctime</code>===
<syntaxhighlight lang="cpp">#include <ctime>
#include <iostream>
Line 857 ⟶ 858:
}</syntaxhighlight>
Output:
<pre>
Identity(4) takes 0 seconds.
Sum(4) takes 0.01 seconds.
</pre>
===Using <code>std::chrono</code>===
<syntaxhighlight lang="cpp">
// Compile with:
// g++ -std=c++20 -Wall -Wextra -pedantic -O0 func-time.cpp -o func-time
#include <iostream>
#include <chrono>
template<typename f>
double measure(f func) {
auto start = std::chrono::steady_clock::now(); // Starting point
(*func)(); // Run the function
auto end = std::chrono::steady_clock::now(); // End point
return std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count(); // By default, return time by milliseconds
}
/*
Test functions:
identity(): returns a number
addmillion(): add 1,000,000 to a number, one by one, using a for-loop
*/
int identity(int x) { return x; }
int addmillion(int num) {
for (int i = 0; i < 1000000; i++)
num += i;
return num;
}
int main() {
double time;
time = measure([](){ return identity(10); });
// Shove the function into a lambda function.
// Yeah, I couldn't think of any better workaround.
std::cout << "identity(10)\t\t" << time << " milliseconds / " << time / 1000 << " seconds" << std::endl; // Print it
time = measure([](){ return addmillion(1800); });
std::cout << "addmillion(1800)\t" << time << " milliseconds / " << time / 1000 << " seconds" << std::endl;
return 0;
}
</syntaxhighlight>
Output:
<pre>
identity(10) 0 milliseconds / 0 seconds
addmillion(1800) 4 milliseconds / 0.004 seconds
</pre>
=={{header|Clojure}}==
Line 1,069 ⟶ 1,123:
println(`Counting to $count takes ${(finish-start)//1000000}ms`)
}</syntaxhighlight>
=={{header|EasyLang}}==
<syntaxhighlight lang=easylang>
func fua lim .
# this is interpreted
i = 1
while i <= lim
sum += i
i += 1
.
return sum
.
start = systime
print fua 1e8
print systime - start
#
fastfunc fub lim .
# this is compiled to wasm
i = 1
while i <= lim
sum += i
i += 1
.
return sum
.
start = systime
print fub 1e8
print systime - start
</syntaxhighlight>
=={{header|Elena}}==
{{trans|C#}}
ELENA
<syntaxhighlight lang="elena">import system'calendar;
import system'routines;
Line 1,083 ⟶ 1,166:
threadControl.sleep(1000);
new Range(0,10000).filterBy::(x => x.mod
}
Line 1,539 ⟶ 1,622:
current size: N/A 0 0 0
Note: static region values should be zero and may not be meaningful.
=={{header|Insitux}}==
Yes, non-transpiled Insitux really is this slow due to its original and ongoing commission: being shoehorned into a Roblox game.
<syntaxhighlight lang="insitux">(function measure
(let [start result end] [(time) (... . args) (time)])
(str result " took " (- end start) "ms"))
(function fib n
(if (< n 2) n
(+ (fib (dec n))
(fib (- n 2)))))
(measure fib 35)
;returns "9227465 took 26497ms"</syntaxhighlight>
=={{header|Ioke}}==
Line 2,309 ⟶ 2,407:
[2.7, 2.8, 31.4, 38.1, 58.0, 76.2, 100.5, 130.0, 149.3, 180.0]
using ''qsort()'' from [[Quicksort#Python|Quicksort]]. Timings show that the implementation of ''qsort()'' has quadratic dependence on sequence length ''N'' for already sorted sequences (instead of ''O(N*log(N))'' in average).
=={{header|Quackery}}==
<code>time</code> returns system time since Unix epoch in microseconds, but is not reliable to the microsecond, so we are using millisecond granularity. Process time is not available.
<syntaxhighlight lang="Quackery"> [ time ]'[ do
time swap - 1000 / ] is time: ( --> n )
time: [ 0 314159 times 1+ echo ]
cr cr
say "That took about " echo say " milliseconds."</syntaxhighlight>
{{out}}
<pre>314159
That took about 392 milliseconds.
</pre>
=={{header|R}}==
Line 2,494 ⟶ 2,610:
#11CAh SYSEVAL tick -
B→R 8192 / 1 FIX RND STD
≫ ≫
|
Store current system time
Execute function
Line 2,505 ⟶ 2,621:
{{in}}
<pre>
≪ 1 1000 START NEXT ≫
</pre>
{{out}}
Line 2,511 ⟶ 2,627:
1: 6.4
</pre>
Yes, more than 6 seconds to loop 1000 times is quite slow.
HP-49+ models have a built-in <code>TEVAL</code> command.
=={{header|Ruby}}==
Line 2,961 ⟶ 3,079:
{{libheader|Wren-check}}
The only way Wren currently has to time a function (encapsulated in the ''Benchmark.run'' method) is to measure the System time before and after the function is called. We therefore use that approach, averaging over say 100 runs, having first shut down as many other processes as we can.
<syntaxhighlight lang="
Benchmark.run("a function", 100, true) {
| |||