When Math Pattern Hunter runs the program uses function
templates, or types, to create potential matching functions.
An example of this would be a number of rational functions
multiplied together. This document describes the setup of the
different types available to use when running the program and
give examples of how to configure the options associated with
each type. The templates / types in the program are
defined in the source code file `fntemplates-types.h`

.
The following are the sections for this page:

- Fn_Terms
- Fn_Term_Sums
- Fn_Term Linear Combos
- Fn_Term Multiplications
- Fn_Term_Sum Multiplications
- Fn_Term Linear Combos Multiplications
- Sum_Terms

The `fn_term`

type is the only type that is enabled
by default. All of the other templates are based on this type.
The `fn_term`

type represents (mostly) rational
functions, or at least functions that can be described by
multiplied fractions and fractional exponents. The diagrams
at this page are examples
of `fn_term`

s.

Each `fn_term`

has a set of nodes and pointers to
each of the three other fn_terms: the numerator (num_term),
the denominator (denom_term), and the exponent (exp_term)
(in the source code this type is setup as a linked-list-like
structure). For a given depth, `d`

, the maximum
number of non-NULL `fn_term`

s attached
to a given start term is `d`

. For example, if
`1 <= d <= 2`

the following templates will be
generated by the program (the format of each `fn_term`

is n/d*(given fn_term)^e):

```
f, n*f, 1/d*f, and f^e
```

The depth can be set by the "`--depth`

"
option (the default is two).

Each `fn_term`

node is filled in with a function
and variables for each of the function's indices. When
evaluating the overall functions each node value is computed
and placed in the overall formula to compute the value of
the total `fn_term`

(as opposed to the individual
`fn_term`

s at each node).

`Fn_Term_Sum`

s represent sums of `fn_term`

s.
For this type the depth option describes the maximum number of
`fn_term`

s that can be summed for a given
`fn_term_sum`

. The following example enables
this type an sets the related parameters for it:

```
$ pattern_hunter {1,3,5,7} --use-fnterm-sums --fnterm-sum-max-depth 2
```

`fn_term`

s. It is possible to duplicate the
functionality of the `fn_term_sum`

s with this type,
so care should be used when chosing what types to run. The
depth for this type is the maximum number of fn_terms that
can be summed (with an appropriate constant multiplied)
for a given linear combo. It is also possible to set the
interval that the integer coefficients in the linear combos
are generated from. The following example demonstrates
how to enable this feature:
```
$ pattern_hunter {5,18,118,1550} --use-fnterm-linear-combos
--fnterm-lc-max-depth 3 --fnterm-lc-coeff-start 2
--fnterm-lc-coeff-end 3
```

The next type allows for multiplications of `fn_term`

s.
All of the forms of `fn_term`

s that can be produced
by enabling this type can be covered by `fn_term`

s
themselves with a higher depth setting. This type basically
remains in the program since it has always been in the
program (...). In this case the depth setting corresponds to
the maximum number of `fn_term`

s that can be
multiplied together in a given `fterm_multiply`

.
The following demonstrates how to enable the type:

```
$ pattern_hunter {0,2,20,294} --depth 2 --use-fnterm-mult
--fnterm-mult-max-depth 2
```

This type should be considered experimental until it has been suficiently tested an debugged so that the segfaults arising from use of this type are far and few between.

That being noted, this type represents multiplications of
`fn_term_sum`

s. The depth option for this type
corresponds to the maximum number of `fn_term_sum`

s
that can be multiplied together for a given object of this type.
Note that since this type relies on another type (where that
type is stacked against the `fn_term`

s) the
number of cases to check when brute-forcing through all
potentially matching functions grows quickly. With this
in mind a user should expect that a run of the Pattern
Hunter including this type may run for hours, or days
(this is also why this form has not been debugged
to the point that the experimental label can be removed). The
following gives an example of the usage:

```
$ pattern_hunter {0,9,36,81} --use-fts-mults
--output-file all_night_run.txt --use-console-progress-bar
```

```
$ less -r all_night_run.txt
```

The last type gives an interesting form for matching functions.
This type has the same properties as the `fn_term`

s
with the numerator `fn_term`

s, and the denominator
and exponent terms, except that instead of having a function
to evaluate at each node, there is a `fn_term_sum`

to evaluate at each node. The depth has the same meaning for
this type as it did for the `fn_term`

s. Note that
this type will likely be more stable than some of the types
with the experimental tag, but a considerable amount of
testing still needs to be done to guarantee that use of this
type will produce the results intended (...). As was the
case for previous types, since this type depends on
other intermediate types the number of cases to check will
quickly grow large, so again expect that a test run could
literally take days to complete. The following
shows how to enable this type:

```
$ pattern_hunter {1/3,1/5,1/7,1/9} --use-sum-terms --sum-term-max-depth 3
```