# Factor 0.94

Version of implementation Factor of programming language FactorStable release of Factor, released on September 18, 2010.

## Examples:

### Hello, World! - Factor (300):

The first line imports `io`

dictionary (`print`

word). The second line pushes the message string on the stack and then calls `print`

which prints the top element of the stack.

```
USE: io
"Hello, World!" print
```

### Factorial - Factor (421):

The first line lists the necessary dictionaries: `formatting`

(`printf`

), `kernel`

(`dup`

), `math`

(arithmetical operators) and `sequences`

(`iota`

).

Next the definition of `factorial`

word follows which replaces an integer `n`

with its factorial on the top of the stack. To do this, it constructs an array of numbers from 0 to `n — 1`

(word `iota`

) and folds it with `1`

using quotation `[ 1 + * ]`

(increment and multiply) and combinator `reduce`

.

The main program constructs a list of numbers from 0 to 16 (`iota`

again) and for each of them (combinator `each`

) applies the quotation which calculates the factorial and outputs the result in required format.

Standard dictionary `math.combinatorics`

contains word `factorial`

defined exactly like this.

```
USING: formatting kernel math sequences ;
IN: factorial-example
: factorial ( n -- n! )
iota 1 [ 1 + * ] reduce ;
17 iota
[ dup factorial "%d! = %d\n" printf ] each
```

### Fibonacci numbers - Factor (422):

This example shows recursive calculation of Fibonacci numbers.

Word `fib`

calculates the n-th number: if the argument is not greater than 1, it stays on the stack as the return value, otherwise it is replaced with a sum of previous numbers. Word `bi`

is a short-hand version of `cleave`

combinator and allows to apply two quotations (in this case calls of `fib`

for smaller arguments) to the same element of the stack (`n`

).

```
USING: formatting kernel math sequences ;
IN: fibonacci-example
: fib ( n -- fib(n) )
dup
1 >
[ [ 1 - fib ] [ 2 - fib ] bi + ]
when ;
16 iota [ 1 + fib "%d, " printf ] each
"...\n" printf
```

### Factorial - Factor (423):

This example uses a purely recursive approach to factorial calculation. Word `factorial`

replaces `n`

with `n!`

on the stack with a side effect: it prints all values of factorial from 0 to `n`

. After `if`

combinator is applied, the stack holds values of `n`

and `n!`

. Words `swap`

and `over`

replace them with `n!`

, `n`

and `n!`

; two latter values are used for printing, and the first one stays on the stack as a return value.

In the main part of the program we need to add `drop`

to remove `16!`

from the stack, so that the effect of the program on the stack is `( -- )`

.

```
USING: formatting kernel math ;
IN: factorial-example
: factorial ( n -- n! )
dup
0 =
[ 1 ]
[ dup dup 1 - factorial * ]
if
swap over "%d! = %d\n" printf ;
16 factorial
drop
```

### Quadratic equation - Factor (424):

Word `quadratic-equation`

takes coefficients of the equation as input and prints the solution while returning nothing. Note that this word is declared using token `::`

instead of `:`

used in most cases; this means that within it lexically scoped variables can be used, in this case parameters `a`

, `b`

and `c`

as well as local variables `d`

, `x0`

and `sd`

bound by `:>`

operator. Such variables can be loaded on the stack using their names. Words and operators which process lexically scoped variables are available in dictionary `locals`

.

Factor provides a built-in data type for complex numbers; whenever the discriminant is negative, its square root will be of type `complex`

. In this case complex roots are printed using words `real-part`

and `imaginary-part`

which extract corresponding parts of a number.

`readln`

reads a string from input stream (till the end of line), and `string>number`

(from `math.parser`

dictionary) converts a string to a floating-point number.

```
USING: formatting io kernel locals math math.functions math.parser ;
IN: quadratic-example
:: quadratic-equation ( a b c -- )
a 0 =
[ "Not a quadratic equation." printf ]
[ b sq a c * 4 * - :> d
b neg a 2 * / :> x0
d sqrt a 2 * / :> sd
d 0 =
[ x0 "x = %f\n" printf ]
[ d 0 >
[ x0 sd + x0 sd - "x1 = %f\nx2 = %f\n" printf ]
[ x0 sd + [ real-part ] [ imaginary-part ] bi "x1 = (%f, %f)\n" printf
x0 sd - [ real-part ] [ imaginary-part ] bi "x2 = (%f, %f)\n" printf ]
if
]
if
]
if ;
readln string>number
readln string>number
readln string>number
quadratic-equation
```

### CamelCase - Factor (425):

This example uses regular expressions. Word `re-split`

(from `regexp`

) splits a string into an array of strings separated by matches to the given regular expression. After this `map`

combinator applies word `>title`

(from `unicode.case`

) to each element of the resulting array, converting them to title case. Finally, `join`

(from `sequences`

) concatenates the strings into one using “” as a separator.

```
USING: kernel io regexp sequences unicode.case ;
readln R/ [^a-zA-Z]+/ re-split
[ >title ] map
"" join print
```

### Factorial - Factor (426):

This example uses a built-in word `factorial`

defined in dictionary `math.combinatorics`

.

```
USING: formatting kernel math.combinatorics sequences ;
17 iota [ dup factorial "%d! = %d\n" printf ] each
```

## Comments

]]>blog comments powered by Disqus

]]>