Compile-time calculation: Difference between revisions

{{task}}

 

Discuss what limitations apply to compile-time calculations in your language.

=={{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));

=={{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.

=={{header|Clojure}}==

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

 

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

 

 

(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> .

 

 

 

long result = 1;

result *= i;

return result;

 

void main() {

=={{header|Factor}}==

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|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|J}}==

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:

 

 

=={{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 ;;

grep 172801 sec.s

movl $<span style="color:red">172801</span>, camlSec

 

=={{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|PicoLisp}}==

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|PureBasic}}==

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

could on a x86 be complied to

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

 

=={{header|REXX}}==

 

10! = 3628800

</pre>

 

=={{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.

</pre>

 

{{omit from|E}}

{{omit from|Java|I've never seen anything like it done and it doesn't seem like the way Java should act}}