Internals

struct Identity <: TransformVariables.ScalarTransform

Identity $x ↦ x$.

struct ArrayTransformation{T<:TransformVariables.AbstractTransform, M} <: TransformVariables.VectorTransform

Apply transformation repeatedly to create an array with given dims.

struct TransformTuple{T} <: TransformVariables.VectorTransform

Transform consecutive groups of real numbers to a tuple, using the given transformations.

struct Fix1{typeof(inverse), T<:TransformVariables.AbstractTransform} <: Function

Partial application of inverse(t, y), callable with y. Use inverse(t) to construct.

abstract type AbstractTransform

Supertype for all transformations in this package.

Interface

The user interface consists of

• dimension
• transform
• transform_and_logjac
• inverse, inverse!
• inverse_eltype.
• nonzero_logprior.
• logprior

abstract type ScalarTransform <: TransformVariables.AbstractTransform

Transform a scalar (real number) to another scalar.

Subtypes must define transform, transform_and_logjac, and inverse. Other methods of of the interface should have the right defaults.

abstract type VectorTransform <: TransformVariables.AbstractTransform

Transformation that transforms <: AbstractVectors to other values.

Implementation

Implements transform and transform_and_logjac via transform_with, and inverse via inverse!.

abstract type LogJacFlag

Flag used internally by the implementation of transformations, as explained below.

When calculating the log jacobian determinant for a matrix, initialize with

logjac_zero(flag, x)

and then accumulate with log jacobians as needed with +.

When flag is LogJac, methods should return the log Jacobian as the second argument, otherwise NoLogJac, which simply combines to itself with +, serving as an empty placeholder. This allows methods to share code of the two implementations.

struct LogJac <: TransformVariables.LogJacFlag

Calculate log Jacobian as the second value.

struct NoLogJac <: TransformVariables.LogJacFlag

Don't calculate log Jacobian, return NOLOGJAC as the second value.

logjac_zero(_, _)

Initial value for log Jacobian calculations.

transform_with(flag::LogJacFlag, transformation, x::AbstractVector, index)

Transform elements of x from index, using transformation.

Return (y, logjac), index′, where

• y is the result of the transformation,

• logjac is the the log Jacobian determinant or a placeholder, depending on flag,

• index′ is the next index in x after the elements used for the transformation

Internal function. Implementations

1. can assume that x has enough elements for transformation (ie @inbounds can be used),

2. should work with generalized indexing on x.

_transform_tuple(flag, x, index, _)

Helper function for transforming tuples. Used internally, to help type inference. Use via transfom_tuple.

_inverse!_tuple(x, index, ts, ys)

Helper function for inverting tuples of transformations. Used internally.

Performs no argument validation, caller should do this.

_inverse_eltype_tuple(ts, _)

Helper function determining element type of inverses from tuples. Used internally.

Performs no argument validation, caller should do this.

unit_triangular_dimension(n)

Number of elements (strictly) above the diagonal in an $n×n$ matrix.

(y, log_r, ℓ) = l2_remainder_transform(flag, x, log_r)

Given $x ∈ ℝ$ and $0 ≤ r ≤ 1$, we define (y, r′) such that

1. $y² + (r′)² = r²$,

2. $y: |y| ≤ r$ is mapped with a bijection from x, with the sign depending on x,

but use log(r) for actual calculations so that large ys still give nonsingular results.

ℓ is the log Jacobian (whether it is evaluated depends on flag).

(x, r′) = l2_remainder_inverse(y, log_r)

Inverse of l2_remainder_transform in x and y.