Compile-time calculation: Difference between revisions

=={{header|360 Assembly}}==

First example with the assembler equivalence pseudo instruction (EQU):

L R1,=A(FACT10) r1=10!

XDECO R1,PG

BR R14 exit

FACT10 EQU 10*9*8*7*6*5*4*3*2*1 factorial computation

{{out}} in the assembler listing ( 375F00 hexadecimal of 10!)

<pre>

</pre>

Second example with an assembler macro instruction:

&LAB FACT &REG,&N parameters

&F SETA 1 f=1

PG DS CL12

YREGS

{{out}} in the assembler listing

<pre>

</pre>

=={{header|6502 Assembly}}==

 

 

 

 

; ROM routines used

 

 

rts

 

 

; the actual value to print

 

{{Out}}

<pre>

**** COMMODORE 64 BASIC V2 ****

READY.

RUN:

 

READY.</pre>

VASM allows you to define values using mathematical operators prior to assembly, but you can only do this with constants.

The following are all valid:

 

MOVE.L #tenfactorial,D1 ;load the constant integer 10! into D1

LEA tenfactorial,A1 ;load into A1 the memory address 10! = 0x375F00

 

=={{header|Ada}}==

Here's a hardcoded version:

with Ada.Text_Io;

procedure CompileTimeCalculation is

Ada.Text_Io.Put(Integer'Image(Factorial));

end CompileTimeCalculation;

And here's a recursive function version that prints the exact same thing.

with Ada.Text_Io;

procedure CompileTimeCalculation is

begin

Ada.Text_Io.Put(Integer'Image(Fact10));

 

===Unbounded Compile-Time Calculation===

An interesting property of Ada is that such calculations at compile time are performed with mathematical (i.e., unbounded) integers for intermediate results. On a compiler with 32-bit integers (gcc), the following code prints the value of '20 choose 10' = 184756:

 

 

procedure Unbounded_Compile_Time_Calculation is

-- Ada.Text_IO.Put_Line -- would not compile

-- ("Factorial(20) =" & Integer'Image(A_11_15 * A_16_20 * F_10));

 

The same compiler refuses to compile the two two lines

 

 

because the final result A_11_15 * A_16_20 * F_10 is a '''value not in range of type "Standard.Integer"''' -- the same intermediate value that was used above to compute '20 choose 10'.

The values of AppleScript 'property' variables are set when a script's compiled, although they can also be changed when the script's run. (If it's a top-level script run from a compiled file, the values of its properties when it finishes are saved back to the file and the properties will start off with those values next time it's run.) Property declarations are single lines, but the lines can be calls to handlers declared upscript from the properties themselves.

 

-- so that the compiler knows about it when compiling the property.

on factorial(n)

on run

return compiledValue

 

{{output}}

 

=={{header|BASIC}}==

Most BASICs perform compile-time calculation on anything they can determine is a constant. This can either be done explicitly:

 

or implicitly:

 

 

In both cases, the identifier <code>factorial10</code> is given the value 3628800 without any runtime calculations, although in many (or perhaps most) BASICs the first one is handled similarly to C's <code>#define</code>: if it isn't used elsewhere in the code, it doesn't appear at all in the final executable.

 

=={{header|C}}==

 

The Order macro library [[Order|implements a full virtual machine and high-level, functional programming language]] available to C programs at compile-time:

#include <order/interpreter.h>

 

printf("10! = %d\n", ORDER_PP( 8to_lit( 8fac(10) ) ) );

return 0;

 

In this example, the <code>8fac</code> function computes the factorial by folding <code>8times</code> (the binary multiplication primitive) over a numeric range created by <code>8seq_iota</code> (which requires <code>8X</code> to be incremented, as it creates lists from L to R-1), a familiar way of computing this in functional languages. The result of the factorial calculation is an internal, "native" number which need to be converted to decimal by the <code>8to_lit</code> function.

===C (simpler version)===

This is a simple version, showing that 10! was computed at compile time:

const int val = 2*3*4*5*6*7*8*9*10;

int main(void) {

printf("10! = %d\n", val );

return 0;

 

{{out}}<pre>10! = 3628800</pre>

</pre>

 

'''Compiler:''' Roslyn C#, language version 7.3

 

The Roslyn compiler performs constant folding at compile-time and emits IL that contains the result.

 

 

public static class Program

Console.WriteLine(FACTORIAL_10);

}

 

{{out|Emitted IL|note=disassembled with ILSpy}}

 

<!--CIL assembly has a similar overall syntax to C#, so colorize it as such.-->

extends [System.Runtime]System.Object

{

} // end of method Program::Main

 

 

Note that the constant field is generated only when both it and the containing class are visible outside of the assembly.

Constant expressions that appear outside of constant declarations are also folded, so

 

 

static class Program

Console.WriteLine(10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1);

}

 

and

 

 

static class Program

Console.WriteLine(factorial);

}

 

produce the same IL, except without the field.

{{out|Emitted IL|note=disassembled with ILSpy}}

 

extends [System.Runtime]System.Object

{

} // end of method Program::Main

 

 

{{out}}

=={{header|C++}}==

This is called [[wp:Template metaprogramming|Template metaprogramming]]. In fact, templates in C++ are Turing-complete, making deciding whether a program will compile undecidable.

 

template<int i> struct Fac

std::cout << "10! = " << Fac<10>::result << "\n";

return 0;

 

Compile-time calculations in C++ look quite different from normal code. We can only use templates, type definitions and a subset of integer arithmetic. It is not possible to use iteration. C++ compile-time programs are similar to programs in pure functional programming languages, albeit with a peculiar syntax.

Alternative version, using constexpr in C++11:

 

 

constexpr int factorial(int n) {

printf("%d\n", f10);

return 0;

Output:

<pre>3628800</pre>

The asm produced by G++ 4.6.0 32 bit (-std=c++0x -S), shows the computation is done at compile-time:

pushl %ebp

movl %esp, %ebp

movl $0, %eax

leave

 

=={{header|Clojure}}==

(defn fac [n] (apply * (range 1 (inc n))))

 

=={{header|Common Lisp}}==

Assuming a definition from [[Factorial function#Common Lisp]], we first have to make a small adjustment so that the function is available at compile time. Common Lisp does not have a single image building and deployment model. For instance, Common Lisp implementations can support a "C like" model whereby a compiler is invoked as a separate process to handle individual files, which are then loaded to form an image (analogous to linking). A Lisp compiler will not make available to itself the functions in a source file which it happens to be compiling, unless told to do so:

 

 

With that, here are ways to do compile-time evaluation:

 

(factorial n))

 

...

 

 

The <code>factorial</code> function must be defined before any use of the <code>ct-factorial</code> macro is evaluated or compiled.

If the data resulting from the compile-time calculation is not necessarily a number or other [http://www.lispworks.com/documentation/HyperSpec/Body/03_abac.htm self-evaluating object], as it is in the factorial case, then the macro must quote it to avoid it being interpreted as code (a form):

 

`(quote ,(factorial n)))

 

; or, equivalently,

(defmacro ct-factorial (n)

 

It is also possible to have a value [http://www.lispworks.com/documentation/HyperSpec/Body/s_ld_tim.htm computed at ''load time''], when the code is loaded into the process, rather than at compile time; this is useful if the value to be computed contains objects that do not yet exist at compile time, or the value might vary due to properties which might be different while yet using the same compiled program (e.g. pathnames), but it is still constant for one execution of the program:

 

 

Further it's also possible to have the value computed at read time using the read macro <code>#.</code> .

 

 

Lastly, Common Lisp has "compiler macros" which are user-defined handlers for function call optimization. A compiler macro is defined which has the same name as some user-defined function. When calls to that function are being compiled, they pass through the macro. The macro must analyze the arguments and rewrite the function call into something else, or return the original form.

 

(if (constantp arg)

(factorial arg)

 

Test with CLISP (taking advantage of its <code>!</code> function) showing how a factorial call with a constant argument of 10 ends up compiled to the constant 3268800, but a factorial call with the argument a is compiled to a variable access and function call:

=={{header|D}}==

The D compiler is able to run many functions at compile-time [http://dlang.org/function.html#interpretation Compile Time Function Execution (CTFE)]:

long result = 1;

foreach (immutable i; 2 .. x + 1)

 

printf("%ld\n", fact10);

 

The 32-bit asm generated by DMD shows the computation is done at compile-time:

push EAX

mov EAX,offset FLAT:_DATA

xor EAX,EAX

pop ECX

 

=={{header|Delphi}}==

In DWScript, constant expressions and referentially-transparent built-in functions, such as ''Factorial'', are evaluated at compile time.

 

 

=={{header|EchoLisp}}==

'''define-constant''' may be used to compute data, which in turn may be used in other define-constant, or in the final code.

(define-constant DIX! (factorial 10))

(define-constant DIX!+1 (1+ DIX!))

(writeln DIX!+1)

3628801

 

=={{header|Erlang}}==

Technically, this calculation happens at parse-time, before any compilation takes place. Calculating factorial at compile-time is not useful in Factor.

 

 

 

=={{header|Forth}}==

During a word definition, you can drop out of the compilation state with '''[''' and go back in with ''']'''. (This is where the naming conventions for '''[CHAR]''' and '''[']''' come from.) There are several flavors of '''LITERAL''' for compiling the result into the word.

 

 

: main ." 10! = " [ 10 fac ] literal . ;

see main

: main

 

Outside of a word definition, it's fuzzy. If the following code is itself followed by a test and output, and is run in a script, then the construction of the '''bignum''' array (and the perhaps native-code compilation of '''more''') happens at runtime. If the following code is followed by a command that creates an executable, the array will not be rebuilt on each run.

 

: more ( "digits" -- ) \ store "1234" as 1 c, 2 c, 3 c, 4 c,

parse-word bounds ?do

more 73167176531330624919225119674426574742355349194934

more 96983520312774506326239578318016984801869478851843

 

=={{header|Fortran}}==

In Fortran, parameters can be defined where the value is computed at compile time:

 

implicit none

 

end program test

 

=={{header|FreeBASIC}}==

 

' Calculations can be done in a Const declaration at compile time

Const factorial As Integer = 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 * 10

Print factorial ' 3628800

 

=={{header|Go}}==

Constant expressions are evaluated at compile time. A constant expression though, is pretty simple and can't have much more than literals, operators, and a special thing called iota. There is no way to loop in a constant expression and so the expanded expression below is about the simplest way of completing this task.

 

import "fmt"

func main() {

fmt.Println(2*3*4*5*6*7*8*9*10)

 

=={{header|Haskell}}==

With Template Haskell, it is quite easy to do compile time embedding. The functions used at compile-time need to be already compiled. Therefore, you generally need two modules.

 

import Language.Haskell.TH.Syntax

 

 

factQ :: Integer -> Q Exp

 

import Factorial

 

 

Note: Doing <code>$([|fact 10|])</code> is the same than doing <code>fact 10</code>. <code>[|something|]</code> returns the abstract syntax tree of <code>something</code>. Thus <code>[|fact 10|]</code> returns the AST of the call to the <code>fact</code> function with 10 as argument. <code>$(something)</code> waits for an AST from a call to <code>something</code>.

Thus, a program which prints 10 factorial:

 

 

When the definition of pf10 is examined, it contains the value 3628800. J has several ways of representing tacit programs. Here all five of them are presented for this program (the last two happen to look identical for this trivial case):

 

 

pf10

└─ " ──────┴─ _

smoutput@(3628800"_)

 

Finally, when this program is run, it displays this number:

 

 

Note: Currently, the mediawiki implementation is corrupting the above display due to a cascading sequence of bad design decisions and mis-interpreted specifications on the part of someone "contributing" to that implementation. To work around this issue, and see the original display, you can currently use either the "Edit" or "View Source" option, depending on whether you are logged in to rosettacode with an account that has edit rights here. (Please don't actually save changes though.) If you are using View Source, you might want to do that in a new tab (so you also stay here with this view) and use your browser's search capability to quickly scroll to this location in the source view.

 

=={{header|Julia}}==

Julia includes a powerful macro feature that can perform arbitrary code transformations at compile-time (or technically at parse-time), and can also execute arbitrary Julia code. For example, the following macro computes the factorial of <code>n</code> (a literal constant) and returns the value (e.g. to inline it in the resulting source code)

factorial(n)

If we now use this in a function, e.g.

then the value of 10! = 3628800 is computed at parse-time and is inlined in the compiled function <code>foo</code>, as can be verified by inspecting the assembly code via the built-in function <code>code_native(foo, ())</code>.

 

=={{header|Kotlin}}==

Compile time calculations are possible in Kotlin using the 'const' modifier provided one sticks to literals or other constants when specifying the calculation to be performed:

const val TEN_FACTORIAL = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2

 

fun main(args: Array<String>) {

println("10! = $TEN_FACTORIAL")

 

{{out}}

=={{header|Lingo}}==

As an interpreted language with the interpreter always being present, Lingo has no clear separation of compile-time and runtime. Whenever you change the code of a script at runtime, it's immediately (re)compiled to bytecode (in memory). You can also create new scripts at runtime:

m = new(#script)

 

 

put fac10()

 

=={{header|Lua}}==

Lua's compiler will attempt to fold constant expressions, which appears to be enough to satisfy this specific task's requirements:

{{out}}<pre>3628800</pre>

Proof via disassembly (Lua 5.3 used - the lookup of global "print" may vary a bit among 5.x versions, but not significant):

This example uses m4 as a front end to [[AWK]]. m4 calculates factorial of 10, where AWK program calls macro.

 

`ifelse($1, 0, 1, `eval($1 * factorial(eval($1 - 1)))')')dnl

dnl

BEGIN {

print "10! is factorial(10)"

 

One runs <code>m4 program.m4 > program.awk</code> to make this valid AWK program.

 

print "10! is 3628800"

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Mathematica is not a compiled language, you can construct compiled functions in Mathematica by the build-in function "Compile". Constants are calculated at "compile-time".

{{Out}}

<pre>CompiledFunction[{},3628800,-CompiledCode-]</pre>

{{Out}}

<pre>3628800</pre>

 

=={{header|Nim}}==

Nim can evaluate procedures at compile-time, this can be forced by calling a procedure with a const keyword like so:

 

result = 1

for i in 2..x:

 

const fact10 = fact(10)

 

We can see that this is evaluated at compile-time by looking at the generated C code:

 

STRING_LITERAL(TMP122, "3628800", 7);

 

The Nim compiler can also be told to try to evaluate procedures at compile-time even for variables by using the --implicitStatic:on command line switch.

=={{header|Oberon-2}}==

Works with oo2c Version 2

MODULE CompileTime;

IMPORT

Out.String("10! =");Out.LongInt(tenfac,0);Out.Ln

END CompileTime.

 

=={{header|Objeck}}==

Objeck will fold constants at compiler time as long as the -s2 or -s3 compiler switches are enabled.

 

bundle Default {

class CompileTime {

}

}

 

=={{header|OCaml}}==

OCaml does not calculate operations that involve functions calls, as for example factorial 10, but OCaml does calculate simple mathematical operations at compile-time, for example in the code below <code>(24 * 60 * 60)</code> will be replaced by its result <code>86400</code>.

 

let conv = 24 * 60 * 60 in

(n * conv)

 

It is easy to verify this using the argument <code>-S</code> to keep the intermediate assembly file:

If you wish to verify this property in your own projects, you have to know that integer values most often have their OCaml internal representation in the assembly, which for an integer <code>x</code> its OCaml internal representation will be <code>(((x) << 1) + 1)</code>. So for example if we modify the previous code for:

 

 

let days_to_seconds n =

(n * conv)

 

# (24 * 60 * 60) lsl 1 + 1 ;;

However, with the introduction of [https://github.com/ocaml-flambda/flambda-backend Flambda] (an alternative intermediate language, inliner, and optimiser), OCaml compilers which equip this backend have a limited ability to reduce pure and annotated function calls to constants:

 

let rec factorial n =

if n = 1 then n else n * factorial (n-1)

(* The unrolled annotation is what allows flambda to keep reducing the call

* Beware that the number of unrollings must be greater than or equal to the

 

The assembler output (cleaned up and demangled a little) shows exactly what's expected, stored as data

You can do any calculation you want before or after, create constants, ...

 

 

You can also calculate all factorials for 1 to 20 before defining fact method :

: fact(n) n ifZero: [ 1 ] else: [ ALLFACTS at(n) ] ;

 

 

{{out}}

To dimension a static array, the macro Pling10 is resolved at compile time. The overall compile time (ready to execute) was around 23 milliseconds.

 

'LIBRARY CALLS

'=============

o2_exec 'Run the program

end if

 

=={{header|Oz}}==

import

System Application

{System.showInfo "10! = "#Fac10}

{Application.exit 0}

 

Code in the <code>prepare</code> section of a functor is executed at compile time. External modules that are used in this code must be imported with a <code>require</code> statement (not shown in this example). Such external functors must have been compiled before the current functor is compiled (<code>ozmake</code> will automatically take care of this).

as the values can be resolved.

 

program in out;

 

 

end;

 

=={{header|Perl}}==

There are few limits on code you can put in <code>BEGIN</code> blocks, which are executed at compile-time. Unfortunately, you can't in general save the compiled form of a program to run later. Instead, <code>perl</code> recompiles your program every time you run it.

 

print "$tenfactorial\n";

 

BEGIN

{$tenfactorial = 1;

 

Note however that all constant folding is done at compile time, so this actually does the factorial at compile time.

 

 

=={{header|Phix}}==

The Phix compiler uses constant folding/propagation, so running p -d on the following snippet

produces a listing file containing

<pre>

runs, arbitrary expressions can be executed with the backqoute and tilde

operators ([http://software-lab.de/doc/ref.html#macro-io read macros]).

(apply * (range 1 N)) )

 

(de foo ()

Output:

<pre>: (pp 'foo) # Pretty-print the function

 

=={{header|PL/I}}==

/* Factorials using the pre-processor. */

test: procedure options (main);

 

end test;

 

Output from the pre-processor:

 

/* Factorials using the pre-processor. */

test: procedure options (main);

put skip list ('factorial 6 is ', y);

end test;

 

Execution results:

 

factorial 4 is 24

factorial 6 is 720

 

=={{header|PowerShell}}==

function fact([BigInt]$n){

if($n -ge ([BigInt]::Zero)) {

"$((Measure-Command {$fact = fact 10}).TotalSeconds) Seconds"

$fact

<b>Output:</b>

<pre>

 

goal_expansion/2 will change the goal in the code at compile time to be something else, in the case the constant number.

fact(X, 1) :- X<2.

fact(X, F) :- Y is X-1, fact(Y,Z), F is Z*X.

test :-

F = factorial_of(10),

{{out}}

<pre>

=={{header|PureBasic}}==

PureBasic will do most calculation during compiling, e.g.

could on a x86 be complied to

<pre>MOV dword [v_a],3628800</pre>

To compute and print 10! during compilation:

 

 

To compute 10! during compilation and print the result at runtime:

 

 

Any Quackery code can be executed during compilation, but the programmer must bear in mind that the compiler uses the stack, so executed code should have no overall stack effect in the case of <code>now!</code>, or leave a single item on the stack to be compiled in the case of <code>constant</code>.

Racket, like most Lisp descendants, allows arbitrary code to be executed at compile-time.

 

#lang racket

 

;; use the macro defined above

(fact10)

 

=={{header|Raku}}==

(formerly Perl 6)

 

 

Like Perl 5, we also have a BEGIN block, but it also works to introduce a blockless statement,

 

 

=={{header|REXX}}==

 

Since REXX is an interpreted language &nbsp; (as are other languages entered for this Rosetta Code task), &nbsp; run time is compile time.

 

say '10! =' !(10)

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

'''output'''

<pre>

 

=={{header|Ring}}==

a = 10*9*8*7*6*5*4*3*2*1

b = factorial(10)

 

func factorial nr if nr = 1 return 1 else return nr * factorial(nr-1) ok

 

=={{header|Rust}}==

The Rust compiler can automatically do optimizations in the code to calculate the factorial.

 

let mut total = 1;

for i in 1..n+1 {

fn main() {

println!("Factorial of 10 is {}.", factorial(10));

 

If we compile this with <code>rustc factorial.rs -O --emit asm</code> and inspect the outputted assembly, we can see <code>movq $3628800, (%rsp)</code>. This means the result of 3628800 was calculated in compile-time rather than run-time.

 

=={{header|Scala}}==

val tenFactorial = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2

 

 

println(s"10! = $tenFactorial", tenFac)

As it can been seen in the always heavily optimized run-time code the calculations are already computed for the field constant and function method.

<pre>

The ! operator is predefined, so no user defined function is necessary.

 

 

const proc: main is func

begin

writeln(factorial);

 

=={{header|Sidef}}==

The compile-time evaluation is limited at a constant expression, which cannot refer at any other user-defined data, such as variables or functions.

 

or:

 

=={{header|Tcl}}==

 

{{works with|Tcl|8.5}}

set exp 1

for {set i 2} {$i <= $n} {incr i} {

return "expr \{$exp\}"

}

How to show that the results were compiled? Like this:

ByteCode 0x0x4de10, refCt 1, epoch 3, interp 0x0x31c10 (epoch 3)

Source "expr {1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 * 10}"

(0) push1 0 # "3628800"

(2) done

As you can see, that expression was transformed into just a push of the results (and an instruction to mark the end of the bytecode segment).

 

=={{header|Ursala}}==

Any user-defined or library function callable at run time can also be called at compile time

and evaluated with no unusual ceremony involved.

 

x = factorial 10

#executable&

 

some notes:

* <code>x</code> is declared as a constant equal to ten factorial using the <code>factorial</code> function imported from the <code>nat</code> library.

The Roslyn compiler performs constant folding at compile-time and emits IL that contains the result.

 

Const FACTORIAL_10 = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1

 

Console.WriteLine(FACTORIAL_10)

End Sub

 

{{out|Emitted IL|note=disassembled with ILSpy}}

 

<!--CIL assembly has a similar overall syntax to C#, so colorize it as such.-->

extends [System.Runtime]System.Object

{

} // end of method Program::Main

 

 

Constant expressions that appear outside of constant declarations are also folded, so

 

Sub Main()

Console.WriteLine(10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1)

End Sub

 

and

 

Sub Main()

Dim factorial As Integer

Console.WriteLine(factorial)

End Sub

 

produce the same IL, albeit without the constant field that other assemblies can reference.

 

{{out|Emitted IL|note=disassembled with ILSpy}}

extends [System.Runtime]System.Object

{

} // end of method Program::Main

 

 

{{out}}

Also Wren has no notion of constants - at compile time or otherwise - and is thoroughly object-oriented. Even literals such as ''123'' and ''true'' are technically instances of the immutable built-in classes Num and Bool.

 

 

Not that it makes much difference in practice as the compiler which is written in C is so quick (at least with scripts of moderate length and on modern hardware) that the compile and runtime stages are indistinguishable to the user.

 

 

{{out}}

=={{header|XLISP}}==

Macros can be used to evaluate expressions at compile time:

If the expression is <i>quoted</i>, however, it is <i>not</i> evaluated—it is inserted 'as is', and will be evaluated at run time:

To show what is going on, first start a REPL and define little functions that just invoke each macro:

 

TEST-F10-CT

[2] (defun test-f10-rt () (f10-at-run-time))

 

Then use <tt>DECOMPILE</tt> to examine the bytecode generated for each function. First, the one where the calculation was performed at compile time:

<pre>[3] (decompile test-f10-ct)

 

=={{header|XPL0}}==

IntOut(0, 10*9*8*7*6*5*4*3*2);

Generates this 80386 assembly code:

<pre>

RET

</pre>

 

=={{header|zkl}}==

zkl has two ways to do compile time calculations: a variant of C's macros and "parse time" calculations (since the compiler is written in zkl, the parser just recurses).

File foo.zkl:

 

#fcn fact(N) { [1..N].reduce('*).println(" tokenize time"); ""}

#tokenize fact(10)

 

Run the program: zkl foo:

{{out}}

=={{header|Zig}}==

Zig provides arbitrary CTFE with limitations in IO, memoization and forbidding closures for compilation efficiency.

fn factorial(n: u64) u64 {

var total: u64 = 1;

const res = comptime factorial(10); // arbitrary Compile Time Function Evaluation

std.debug.print("res: {d}", .{res}); // output only at runtime

Output:

<pre>3628800</pre>