(delimited by <hs></hs>) to answer the question:
   
   Explain the Answer to me in a way that actuarially trained people will understand. The purpose of the answer is to help people understand how to make functions that will be used in m2 files.
   
   I'm going to show you what output I would like using the following function called "Rank" as an example input you'll receive.
 
```
   func Rank(_value float64, _values []float64, descending bool) float64 {{
if len(_values) == 0 {{
panic("At least one value must be provided to Rank to compare against.")
}}
rank := 1.0
for i := range _values {{
if (descending && _value < _values[i]) || (!descending && _value > _values[i]) {{
rank += 1
}}
}}
return rank
   }}
‍
```    

     Start the answer with a heading called "Description" that explains what the function does at a high level. Using the 'Rank' function as an example, here's what that would look like:    

```
   Rank determines the rank of a value within a set of values. The rank is determined based on whether the ranking is in ascending (default) or descending order. In the case of a tie the value provided is considered to be the lowest rank. The rank starts at 1.
‍
```    

    Follow this with a section called "Parameters:" explaining what the parameters of the function are and what they mean.
   Parameters that start with '_' are positional parameters, otherwise they are named parameters.
   You can remove the '_' when explaining the parameters.
   Named parameters are optional and have a default value.
   Parameters that start with 'has' do not need to be included in this section.
   
   Using the 'Rank' function as an example, here's what that would look like:    

```
m2 Parameters:
   - value - optional, a numeric value whose rank needs to be determined.
   - values - optional, an array of numeric values against which `value` is compared to determine its rank.
   - descending - a parameter with a default, a True or False (default) flag that determines if the ranking should be performed in ascending or descending order. If the parameter is specified by user as True, the ranking is performed in descending order, otherwise in ascending order.    

```
   Follow this with a section called "Result:"  which explains the output of the function.
   Using the 'Rank' function as an example, here's what that would look like:    

```
   Result:
   A single whole number representing the rank of the requested values within the specified array
‍
```  
   Follow this with a section called "Exceptions:"
   Exceptions lists the errors that can be thrown by the function, and which values must be set.    
   Using the 'Rank' function as an example, here's what that would look like:    

```
     Errors:
   - "At least one value must be provided to Rank to compare against." error is returned if no values
         are specified.
‍
   ```    
    Follow this with a section called "Examples:"
   The examples must look like code found in .m2 files and results.
   Different examples should reflect the different ways in which parameters can be used. If you can, you need to suppress the has___ boolean parameters from the explanation. They're meant to be hidden and not exposed to users.
‍
   The construct where you'll see them is something like this function signature:
‍
   ```
   func LessThan(_values []float64, hasLimit bool, limit float64, limits []float64) []float64 {{
    ...function in here
   }}
‍
   ```
   'limit' and 'limits' are both optional but one needs to be provided. The hasLimit boolean indicates to us at runtime if the limit was specified in the function or not. Since Go instantiates a float64 to a 0 value it's impossible to tell whether it wasn't passed or it was passed with a value of 0. The M2 interpreter therefore helps us out at runtime by setting the has parameter to true if it was there.
   
   All of this isn't meant to be exposed to users, so in the help docs we're leaving out the has parameter and simply saying one of limit or limits  needs to be provided. Also the example should therefore just be
   
   ```
   var result = LessThan(values, limit: 3)
‍
   ```    
Another pattern you'll see is where a function has a named parameter that has an enum type. Normally denoted where a parameter is of type `types.MonthTiming` or `types.Frequency` or starting with `types.`
   
   ```
   func IRR(_series []float64, timing types.MonthTiming, frequency types.Frequency) float64 {{
       f, err := fin.IRR(_series, timing, frequency)
       if err != nil {{
           return math.NaN()
       }}
       return f
   }}
‍
   ```
   When you see this you should include parameters as a named parameters in the example you answer with. or example you'll note how the timing and frequency parameters are specified below

```
   var irr = IRR(mos_profit_after_tax, timing: EndMonth, frequency: Monthly);

```
   Using the 'MonthlyForwardRatesFromSpotRate' function as an example, here's what that would an output would like:        

```
   Example with Annual spot rate frequency
   var spotRate = 0.05;
   var num_proj_months = 12;
   var result = MonthlyForwardRatesFromSpotRate(spotRate: spotRate, spotRateFreq: Annual, numberMonths: num_proj_months);    
    
    result = [0.004074, 0.004074, 0.004074, 0.004074, 0.004074, 0.004074, 0.004074, 0.004074, 0.004074, 0.004074, 0.004074, 0.004074]    Example with Monthly spot rate frequency
   
    var spotRate = 0.01;
   var numberMonths = 6;
   var result = MonthlyForwardRatesFromSpotRate(spotRate: spotRate, spotRateFreq: Monthly, numberMonths: num_proj_months);    

    result = [0.01, 0.01, 0.01, 0.01, 0.01, 0.01]    

    Example with Daily spot rate frequency
   var spotRate = 0.0002;
   var spotRateFreq = Daily;
   var numberMonths = 3;
   var result = MonthlyForwardRatesFromSpotRate(spotRate: spotRate, spotRateFreq: Daily, numberMonths: num_proj_months);    
    
    result = [0.006135, 0.006135, 0.006135]
   
```        
    Follow this with a section called "Notes:"
   This section contains useful information about the function including examples that would throw an error, or interesting behavior that is not obvious.

   
   In general please follow these rules when writing the answer:
       Do not use example code that looks like golang code.
       If the function also returns an error you don't need to mention that in your answer.
       Do not include error checking code.
       Don't include notes about functions that are called from within the function
       Do not use example code based on Excel formula.
       Don't refer to "Actuarially trained people".
       When talking about parameters in the function please use the following replacements when you output the answer:
   - float64 -> number
   - float -> number
   - int -> integer
   - int64 -> integer
   - symbol -> string
   ------
   <ctx>
   {context}
   </ctx>
   ------
   <hs>
   {history}
   </hs>
   ------
   {question}
   Answer:
   """

```
Description:

SnapToZero function is used to snap values, within a specified tolerance, to zero. It applies this to every value in an array of numbers. The function takes two parameters: a list of numeric values and a tolerance value. Each value in the list is compared to the tolerance, and if it falls within the tolerance, it is snapped to zero.

Parameters:
‍
- values - mandatory, an array of numeric values that are to be evaluated.
- tolerance - mandatory, the numeric value that determines the range within which numbers are snapped to zero.

Result:
‍
An array of numeric values where values within the tolerance are snapped to zero.

Examples:
‍
```
var values = [0.0001, 0.2, 0.0003, 0.4];
var tolerance = 0.001;
var result = SnapToZero(values, tolerance);
‍
```
Result would be: [0, 0.2, 0, 0.4]

Notes:
‍
The SnapToZero function can be useful in scenarios where minor deviations from zero (that could occur due to floating-point arithmetic precision, for instance) should be ignored. The tolerance parameter allows the user to define what constitutes a 'minor' deviation.

```
Description:

The 'DistanceToMean' function computes the distance of each value in a set of values (array) from the mean of the set. It returns an array where each element is the original value minus the mean of the original set of values.    
‍
Parameters:

- values - optional, an array of numeric values from which the mean will be calculated and the distances of each individual value from this mean will be computed.    

Result:

An array of numeric values representing the distances of each original value from the mean of the set. The returned array has the same length as the input array 'values'.    

Errors:

No specific errors are thrown by this function.    

Examples:

```
var values = [1.0, 2.0, 3.0, 4.0, 5.0];
var result = DistanceToMean(values);    

result = [-2.0, -1.0, 0.0, 1.0, 2.0] // as the mean of the 'values' is 3.0
‍
```    
Notes:
 
The function does not modify the original array of values. Instead, it creates a copy of the input array and then modifies this copy. Therefore the original array remains unchanged.

```
Description:
   
The Increment function generates an array of sequential integers. The length of the array is determined by the '_length' parameter and the starting value of the sequence is determined by the '_start' parameter. This sequence increases by an increment of 1 for each subsequent value.    

Parameters:
   
- length - an integer determining the length of the output array.
- start - an integer determining the starting value of the sequence.    

Result:
‍
An array of integers, starting from 'start' and incrementing by 1 for 'length' number of times.    

Exceptions:
   
None. This function does not throw any exceptions.    

Examples:
   
```
   
var length = 5;
var start = 1;
var result = Increment(length: length, start: start);    

result = [1, 2, 3, 4, 5]    

var length = 3;
var start = 0;
var result = Increment(length: length, start: start);    

result = [0, 1, 2]
   

```
Notes:
   
The function does not check if the 'length' parameter is less than or equal to 0. If this is the case, it will return an empty array. Similarly, it does not check if 'start' is negative. If it is, the sequence will start from the negative value and increment up towards zero and beyond.

```