Data

Table([options], ...; ...)

Tabular data with options, corresponding to table[options] { ... } in PGFPlots.

options stores the options. If that is followed by an AbstractString, that will be used as a filename to read data from, otherwise all the arguments are passed on to TableData.

Examples:

Table(["x" => 1:10, "y" => 11:20])        # from a vector

Table([1:10, 11:20])                      # same contents, unnamed

Table(Dict(:x => 1:10, :y = 11:20))       # a Dict with symbols

@pgf Table({ "x index" = 2, "y index" = 1 }, randn(10, 3))

let x = range(0; stop = 1, length = 10), y = range(-2; stop =  3, length = 15)
    Table(x, y, sin.(x + y'))             # edges & matrix
end

Tabular data with optional column names.

This corresponds to the part of tables between {}'s in PGFPlots, without the options or table, so that it can also be used for “inline” tables. Table will call the constructor for this type to convert arguments after options.

data is a matrix, which contains the contents of the table, which will be printed using print_tex. colnames is a vector of column names (converted to string), or nothing for a table with no column names.

When rowsep is true, an additional \\ is used as a row separator. The default is true, this is recommended to avoid “fragility” issues with inline tables.

After each index in scanlines, extra row separators are inserted. This can be used for skipping coordinates or implicitly defining the dimensions of a matrix for surf and mesh plots. They are expanded using expand_scanlines.

Coordinates(itr)

Convert the argument, which can be any iterable object, to coordinates.

Specifically,

• Coordinate and Nothing are passed through as is,

• 2- or 3-element tuples of finite real numbers or strings are interpreted as coordinates,

• (), and tuples with non-finite numbers become nothing (representing empty lines).

The resulting coordinates are checked for dimension consistency.

Examples

The following are equivalent:

Coordinates((x, 1/x) for x in -5:5)
Coordinates(x == 0 ? () : (x, 1/x) for x in -5:5)
Coordinates(x == 0 ? nothing : Coordinate((x, 1/x)) for x in -5:5)

Use enumerate to add 1, 2, … for the x-axis to an existing set of y coordinates:

Coordinates(enumerate([1, 4, 9]))

Coordinates(
    x,
    y;
    xerror,
    yerror,
    xerrorplus,
    yerrorplus,
    xerrorminus,
    yerrorminus,
    meta
)

Two dimensional coordinates from two vectors, with error bars.

Coordinates(
    x,
    y,
    z;
    xerror,
    yerror,
    zerror,
    xerrorplus,
    yerrorplus,
    zerrorplus,
    xerrorminus,
    yerrorminus,
    zerrorminus,
    meta
)

Three dimensional coordinates from two vectors, with error bars.

Coordinates(x, y, z; meta)

Construct coordinates from a matrix of values and edge vectors, such that z[i,j] corresponds to x[i] and y[j]. Empty scanlines are inserted, consistently with the mesh/ordering=x varies option of PGFPlots (the default).

x = range(0; stop = 1, length = 10)
y = range(-1; stop = 2, length = 13)
z = sin.(x) + cos.(y')
Coordinates(x, y, z)

Coordinate(data; error, errorplus, errorminus, meta)

Construct a coordinate, with optional error bars and metadata. data should be a 2- or 3-element tuples of finite real numbers.

You can specify either

1. error, which will then be used for error bars in both directions, or

2. errorplus and/or errorminus, for asymmetrical error bars.

Error values can be tuples of the same kind as data, or nothing.

Metadata can be provided in meta.

Users rarely need to use this constructor, see methods of Coordinates for constructing coordinates from arrays.

Coordinate(x, y; args...)

Convenience constructor for 2-dimensional coordinates.

Coordinate(x, y, z; args...)

Convenience constructor for 3-dimensional coordinates.

Expression(expressions::Vector{String})

Expression(strings::String...)

An Expression is a string or multiple strings, representing a function, and is written in a way LaTeX understands.

Graphics([options], filename)

Graphics data simply wraps an image (eg a .png file).