# ParametricReference

While the `isosurface` object uses implicit surface functions like F(x,y,z) = 0 the `parametric` object uses is a set of equations for a surface expressed in the form of the parameters that locate points on the surface. For example: `x(u,v)`, `y(u,v)`, `z(u,v)`. Each of the pairs of values for `u` and `v` gives a single point `<x,y,z>` in 3d space.

The `parametric` object is not a solid it is hollow, like a thin shell. The syntax is as follows:

```parametric {
function { FUNCTION_ITEMS },
function { FUNCTION_ITEMS },
function { FUNCTION_ITEMS }

<u1,v1>, <u2,v2>
[contained_by { SPHERE | BOX }]
[accuracy FLOAT_VALUE]
[precompute DEPTH, VarList]
}
```

The default values are:

```accuracy     : 0.001
contained_by : box {<-1,-1,-1>, <1,1,1>}
```
1. The first function calculates the `x` value of the surface, the second `y` and the third the `z` value. Any function that results in a float is allowed.
2. The `<u1,v1>` and the `<u2,v2>` boundaries of the `(u,v)` space, in which the surface has to be calculated.
3. The `contained_by` object limits the area where POV-Ray samples for the surface of the function. The container can either be a `sphere` or a `box`.
4. The `max_gradient` is the maximum magnitude of all six partial derivatives over the specified ranges of u and v.
1. Take `dx/du`, `dx/dv`, `dy/du`, `dy/dv`, `dz/du`, and `dz/dv` and calculate them over the entire range
2. The `max_gradient` should be at least the maximum (absolute value) of all of those values.
3. Choosing a too small of a value will create holes or artifacts in the object.
5. For `accuracy` smaller values produces more accurate surfaces, but take longer to render.
6. Using `precompute` can speedup the rendering of parametric surfaces by simply dividing the parametric surfaces into smaller ones
1. The maximum value for DEPTH is 20. High values of depth can produce arrays that use a lot of memory, take longer to parse and render.
2. It precomputes the ranges for the VarList variables (x,y,z)
3. If you declare a `parametric` surface using `precompute` and then use it twice, all arrays are in memory only once.

Example, a unit sphere:

```parametric {
function { sin(u)*cos(v) }
function { sin(u)*sin(v) }
function { cos(u) }

<0,0>, <2*pi,pi>
contained_by { sphere{0, 1.1} }