Time a function: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
m (→{{header|Wren}}: Changed to Wren S/H) |
|||
| (8 intermediate revisions by 7 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 968 ⟶ 1,022:
{{libheader|SysUtils,StdCtrls}}
[[File:DelphiTimerObject.png|frame|none]]
Here is a simple timer object that I use to time different parts of the code,
The object is based on the TPanel, which means the
The time is controlled by four different
'''Reset'''. Reset zeros the
'''Start'''. Starts the timer running.
'''Stop'''. Stops the timer.
'''Displays'''. Displays the current cumulative time since the first start.
Start and Stop can be moved around the code to control which parts are timed. You can even turn the timer on and off multiple times to messure the combined execution times of multiple different sections of code. You can also move the Start and Stop commands closer and closer together to zoom in on the part of the code that takes the most time to execute.
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,483 ⟶ 2,599:
=={{header|RPL}}==
In its first versions, RPL did not provide user access to system clock - but advanced users knew which system call can be made on their machine to get it. The following code works on a 1987-manufactured HP-28S, but can crash on older ones and will surely do on other machines. If using a newer model, replace <code>#11CAh SYSEVAL</code> by <code>TICKS</code>, which is a (safe) built-in instruction.
{| class="wikitable"
! RPL code
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) {
| |||