Given a simplicial complex , and a sequence of values on each one of
its vertices, one may construct a homotopy of PL functions on the complex that
interpolates linearly between the values. For any given time in the homotopy, we
get a function from the simplicial complex to the real line, and we can compute
its persistence diagram. Stacking all such diagrams together we get a
persistence vineyard [CEM06]. An example that computes such a vineyard is in
`examples/pl-functions/pl-vineyard.cpp`

.

Once compiled, it takes three files as the input:

```
pl-vineyard complex values output-prefix
```

`complex`

lists the simplices of the simplicial complex , one
per-line:

```
0
1
0 1
2
0 2
...
```

`values`

lists the vertex values of the consequtive “frames” of the homotopy.
Each line is a sequence of as many numbers as there are vertices in the complex.
It describes a single frame. **pl-vineayrd** constructs the homotopy over
the interval , where is the number of frames. As an
example of `values`

input:

```
3.3 6 2
1.2 3 10
7.5 2.1 0
```

This input means: . Similarly, ; .

The vineyard is saved to the files prefixed with `output-prefix`

, followed by
the dimension and extension, e.g. `myfunction1.vin`

or `myfunction1.edg`

,
depending on the format. The two formats are vines and edges. The former saves
one vine per line, listed as a stream of triplets BIRTH DEATH TIME:

```
4 5 0 3.4 5.6 0.4 3 6 1 ...
```

The edge format represents the vine as a sequence of edges, each given as a start and end point. So the above vine would appear as:

```
4 5 0
3.4 5.6 0.4
3.4 5.6 0.4
3 6 1
...
```

**pl-vineyard** takes additional options:

- -s, --skip-infinite¶
Do not output infinite vines.

- -v, --save-vines¶
Output vines, instead of the default edge format.

- -e, --explicit-events¶
Go through the events one by one (useful for the debugging).