#### Use pattern matching to write a function which, given two **numbers** x and n, computes x to the power of n.

**numbers**

### Running a standalone program

I’d like to put this on my github, so I skipped ahead to Chapter 16 of the book and learnt just enough to move away from the interactive prompt environment.

**abstract**sets of types and functions into

**modules:**

- To build a module, save your code in a
**.ml**file. OCaml programs live in files with**lowercase**names ending in .ml. - Start your module with a comment explaining the module. Comments are written between (* and *).
- Run
in a terminal to*ocamlc (filename).ml***compile**your program into an**executable pre-compiled module.**You will see the executable in your current directory, with the same file name but ending in**.cmo**. - Run
in the OCaml prompt to load the pre-compiled module into OCaml. Oops, when I ran this to my file, it returned*load “(filename).cmo”;;**Error: Unbound value load.***It seems the book is too outdated and***load*isn’t a command anymore.

### Function power_int: int -> int -> int

I turned to more updated references, e.g., the official OCaml manual or the Real World OCaml book. Following section 1.9 of the manual, I ran the following in the directory my file was in:

*ocamlc -o power_int power_int.ml*

I use the same command ocamlc as above, but I specific the output file name with ‘**-o**‘ to be **power_int**. I tested my program by running:

*./power_int 5 2*

and it returns 25. Yay! It works with positive integers! Well, by integers I mean integers within the range **min_int** and **max_int**, not the mathematical definition, which are not bounded. What about negative integers? When x is negative, it works just fine:

./power_int -5 3

returns -125, as it should. When n is negative, it returns 0 in all the cases I examined. This is because the function evaluates to type **int**, which means that when the value is a non-integer, it rounds to the closest integer that is closest to zero. So it makes sense that 2 to the power of -1 rounds to 0, and -2 to the power of -1 rounds to 0, etc. However, that’s not informative. Time to fix it.

### Function power_float: float -> float -> float

Converting to the type **float**, which stands for **floating point numbers**, fixes two things. First, the program can now take in any number for x (well, again, within the min_float and max_float range of course) instead of integers. Of course, n still has to be integers because of how I recurse the function. Second, the program now returns a floating point number when n is negative. Although not perfect, this function is much closer to what was asked.

To write power_float, I revised power_int by telling OCaml that the arguments are in float with the float operators. The float operators have a ‘.’ to the right of the int operators. E.g., **+.**, **-.**, etc. Make sure to match all operators and operands that an operand interacts with to type float, otherwise there will be a type error.

### What is 0^0?

Both my programs return 1 when both x and n are zero. This is true for a few programming languages, but not all. Some returns undefined. As always, it’s a good idea to check all the boundary cases before proceeding.

Go ahead and test my program! It works! Yay!

Edit: I added a fast exponential version on github! Check it out!