Internals

struct Identity <: TransformVariables.ScalarTransform

Identity $x ↦ x$.

struct ScaledShiftedLogistic{T<:Real} <: TransformVariables.ScalarTransform

Maps to (scale, shift + scale) using logistic(x) * scale + shift.

struct ShiftedExp{D, T<:Real} <: TransformVariables.ScalarTransform

Shifted exponential. When D::Bool == true, maps to (shift, ∞) using x ↦ shift + eˣ, otherwise to (-∞, shift) using x ↦ shift - eˣ.

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]@(ref), inverse!
• inverse_eltype.

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.

!!! NOTE This type is for code organization within the package, and is not part of the public API.

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.

Calculate log Jacobian as the second value.

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),

1. 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, ys)

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.