### GenericQuantity and Quantity Promotion

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Explains and demonstrates the promotion rules when combining a `GenericQuantity` with a standard `Quantity`, resulting in a `GenericQuantity`.

```Julia
x = GenericQuantity(1.5f0)
y = Quantity(1.5, length=1)
println("Promoted type of x and y: ", typeof(x * y))
```

--------------------------------

### Symbolic Units Expansion

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Shows how to create a QuantityArray with symbolic units and then expand it to its standard unit representation using `uexpand`.

```Julia
z_ar = randn(32)
z = QuantityArray(z_ar, us"Constants.M_sun * km/s")
z_expanded = uexpand(z)
println("Expanded z: ", z_expanded)
```

--------------------------------

### Fill QuantityArray

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Demonstrates creating a QuantityArray with a specified unit and size using the `fill` function. It also shows how to create a 0-dimensional QuantityArray.

```Julia
filled_q = fill(u"m/s", 10)
println("Filled QuantityArray: ", filled_q)
```

```Julia
empty_q = fill(u"m/s", ())
println("0 dimensional QuantityArray: ", empty_q)
```

--------------------------------

### Create Similar QuantityArray

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Shows how to create a new QuantityArray with the same properties (units and dimensions) as an existing one using the `similar` function.

```Julia
qa = QuantityArray(rand(3, 4), u"m")
new_qa = similar(qa)
println("Similar qa: ", new_qa)
```

--------------------------------

### Create and Use QuantityArray

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Shows how to create and manipulate `QuantityArray`, which is an array of quantities with the same dimension. Examples include creating arrays from random data and single quantities, performing array operations like `sum`, accessing and modifying elements, and applying functions using broadcasting.

```julia
x = QuantityArray(randn(32), u"km/s")

y = randn(32)
y_q = QuantityArray(y .* u"m * cd / s")

println("Sum x: ", sum(x))

y_q[5] = Quantity(5, length=1, luminosity=1, time=-1)
println("5th element of y_q: ", y_q[5])

println("Stripped y_q: ", ustrip(y_q))

f_square(v) = v^2 * 1.5 - v^2
println("Applying function to y_q: ", sum(f_square.(y_q)))
```

--------------------------------

### QuantityArray Promotion

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Illustrates how QuantityArrays with different precision types but compatible dimensions promote to a common type during operations. It shows the result of `promote` on two QuantityArrays.

```Julia
qarr1 = QuantityArray(randn(32), convert(Dimensions{Rational{Int32}}, dimension(u"km/s")))
qarr2 = QuantityArray(randn(Float16, 32), convert(Dimensions{Rational{Int64}}, dimension(u"km/s")))
println("Promoted type: ", typeof(promote(qarr1, qarr2)))
```

--------------------------------

### Photoelectric Effect Calculation with DynamicQuantities.jl

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Solves a photoelectric effect problem, calculating the wavelength of ejected electrons. Demonstrates automatic unit propagation, dimensional verification, and usage of predefined constants.

```julia
using DynamicQuantities

using DynamicQuantities.Constants: h, m_e

Φ = 4.33u"Constants.eV" # work function

E = 7.2e-19u"J" # incident energy

p = sqrt(2 * m_e * (E - Φ)) # momentum of ejected electrons

λ = h / p # wavelength of ejected electrons

λ |> us"nm" # return answer in nanometers (equivalent to `uconvert(us"nm", λ)`) 
```

--------------------------------

### Custom Dimensions and Operations

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Shows how to define custom dimensions by subtyping `AbstractDimensions` and how these custom dimensions are used seamlessly with `Quantity` and `QuantityArray` for operations.

```Julia
struct MyDimensions{R} <: AbstractDimensions{R}
    cookie::R
    milk::R
end

x = Quantity(1.5, MyDimensions(cookie=1, milk=-1))
y = Quantity(2.0, MyDimensions(milk=1))

x * y

x_qa = QuantityArray(randn(32), MyDimensions(cookie=1, milk=-1))

x_qa .^ 2
```

--------------------------------

### Promote Standard Dimensions to Custom Angle Dimensions

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Illustrates how to enable seamless interaction between quantities with standard `Dimensions` and custom `AngleDimensions`. This involves defining `promote_rule` to specify the promotion behavior and a `convert` method to handle the conversion of quantities.

```julia
function Base.promote_rule(::Type{AngleDimensions{R1}}, ::Type{Dimensions{R2}}) where {R1,R2}
    return AngleDimensions{promote_type(R1, R2)}
end
function Base.convert(::Type{Quantity{T,AngleDimensions{R}}}, q::Quantity{<:Any,<:Dimensions}) where {T,Din,R}
    val = ustrip(q)
    d = dimension(q)
    return Quantity(
        T(val),
        AngleDimensions{R}(;
            d.length, d.mass, d.time, d.current, d.temperature, d.luminosity, d.amount, angle=zero(R)
        )
    )
end
```

--------------------------------

### Specializing Methods for UnionAbstractQuantity

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Shows how to declare methods that accept custom quantity types by specializing on `UnionAbstractQuantity`. This is the recommended approach for broader compatibility with future abstract quantity types.

```julia
function my_func(x::UnionAbstractQuantity{T,D}) where {T,D}
    # value has type T and dimensions has type D
    return x / ustrip(x)
end
```

--------------------------------

### Projectile Motion Simulation with DynamicQuantities.jl

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Simulates projectile motion using DynamicQuantities.jl. Sets up initial conditions with units, calculates velocity components, defines a time vector, and computes position over time. Includes plotting preparation.

```julia
using DynamicQuantities

# Can explicitly import units:
using DynamicQuantities: km, m, s, min

y0 = 10km
v0 = 250m/s
θ = deg2rad(60)
g = 9.81m/s^2

vx0 = v0 * cos(θ)
vy0 = v0 * sin(θ)

t = range(0s, 1.3min, length=100)

x(t) = vx0*t
y(t) = vy0*t - 0.5*g*t^2 + y0

x_si = x.(t)
y_si = y.(t)

x_km = ustrip.(x_si .|> us"km")
y_km = ustrip.(y_si .|> us"km")

# plot(x_km, y_km, label="Trajectory", xlabel="x [km]", ylabel="y [km]")
```

--------------------------------

### Using Custom Quantities and Operations

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Demonstrates the instantiation and usage of custom quantity types, including mathematical operations. Custom quantities behave like standard `Quantity` objects, supporting arithmetic operations and displaying with their dimensions.

```julia
q1 = MyQuantity(1.2, Dimensions(length=-2))
# prints as `1.2 m⁻²`

q2 = MyQuantity(1.5, MyDimensions(cookie=1))
# prints as `1.5 cookie`

q2 ^ 2
# `2.25 cookie²`
```

--------------------------------

### GenericQuantity Construction and Operations

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Demonstrates the creation and usage of `GenericQuantity`, including its ability to wrap custom types like `Coords`. It also shows how arithmetic operations are defined and applied to `GenericQuantity` instances containing custom types.

```Julia
struct Coords
    x::Float64
    y::Float64
end

Base.:+(a::Coords, b::Coords) = Coords(a.x + b.x, a.y + b.y)
Base.:-(a::Coords, b::Coords) = Coords(a.x - b.x, a.y - b.y)
Base.:*(a::Coords, b::Number) = Coords(a.x * b, a.y * b)
Base.:*(a::Number, b::Coords) = Coords(a * b.x, a * b.y)
Base.:/(a::Coords, b::Number) = Coords(a.x / b, a.y / b)

coord1 = GenericQuantity(Coords(0.3, 0.9), length=1)
coord2 = GenericQuantity(Coords(0.2, -0.1), length=1)

coord1 + coord2 |> us"cm"
```

--------------------------------

### Array Concatenation with QuantityArray

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Demonstrates array concatenation for QuantityArrays, ensuring that the resulting array maintains consistent dimensions. It uses `hcat` for horizontal concatenation.

```Julia
qarr1 = QuantityArray(randn(3) .* u"km/s")
qarr2 = QuantityArray(randn(3) .* u"km/s")
concat_qarr = hcat(qarr1, qarr2)
println("Concatenated QuantityArray: ", concat_qarr)
```

--------------------------------

### Define Custom Angle Dimensions

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Demonstrates how to define a custom dimension type `AngleDimensions` that inherits from `AbstractDimensions` to track angles as a unit. This allows for specific handling of angular dimensions in calculations.

```julia
using DynamicQuantities

struct AngleDimensions{R} <: AbstractDimensions{R}
    length::R
    mass::R
    time::R
    current::R
    temperature::R
    luminosity::R
    amount::R
    angle::R
end
```

--------------------------------

### Convert Quantity Value Type

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Demonstrates how to convert a `Quantity` to a different value type, specifically from a default floating-point type to `Float32`. This is useful for memory optimization or when interfacing with systems that require specific data types.

```julia
quantity = 1.5u"m"

convert_q = Quantity{Float32}(quantity)

println("Converted Quantity to Float32: ", convert_q)
```

--------------------------------

### Define and Use 'rad' Constant

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Defines a constant `rad` representing one radian as a `Quantity` with `AngleDimensions`. This allows for convenient use of radians in calculations, ensuring that angular dimensions are tracked correctly.

```julia
const rad = Quantity(1.0, AngleDimensions(angle = 1))
```

--------------------------------

### Define Custom Quantity Type

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Creates a custom quantity type by subclassing AbstractQuantity. This allows for custom value and dimension types, ensuring compatibility with built-in functions like `ustrip` and `dimension` by naming the fields `value` and `dimensions`.

```julia
struct MyQuantity{T,D} <: AbstractQuantity{T,D}
    value::T
    dimensions::D
end
```

--------------------------------

### Set Default Angle Dimension Name

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples

Shows how to set the default string representation for the 'angle' dimension to 'rad' by defining a `dimension_name` method for the custom `AngleDimensions` type. This ensures that angles are displayed as 'rad' by default.

```julia
import DynamicQuantities: DynamicQuantities as DQ

function DQ.dimension_name(::AngleDimensions, k::Symbol)
    default_dimensions = (
        length = "m",
        mass = "kg",
        time = "s",
        current = "A",
        temperature = "K",
        luminosity = "cd",
        amount = "mol",
        angle = "rad",
    )
    return get(default_dimensions, k, string(k))
end
```

--------------------------------

### Register Custom Unit with @register_unit

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/units

Demonstrates how to register a new custom unit using the `@register_unit` macro in Julia. This allows users to define their own units based on existing ones and use them in calculations. The example shows registering 'MyVolt' and performing calculations with it.

```julia
julia> @register_unit MyVolt 1.5u"V"
julia> x = 20us"MyVolt^2"
20.0 MyVolt²
julia> y = 2.5us"A"
2.5 A
julia> x * y^2 |> us"W^2"
281.25 W²
julia> x * y^2 |> us"W^2" |> sqrt |> uexpand
16.77050983124842 m² kg s⁻³
```

--------------------------------

### Get Value in SI Base Units with ustripexpand

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/symbolic_units

The `ustripexpand` function returns the numerical value of a quantity in SI base units. It is a convenience function equivalent to `ustrip(uexpand(q))`, effectively stripping away all unit information and returning a plain numerical value.

```julia
q_symbolic = Quantity(1.0, SymbolicDimensions, km=1, s=-2)
value_si = ustripexpand(q_symbolic)
# value_si will be the numerical value in m/s^2
```

--------------------------------

### Get Denominator of FixedRational

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/api

Retrieves the denominator of a `FixedRational` number, converting it to the same type as the numerator (`T`). This is useful when the fixed denominator type differs from the numerator's type.

```julia
denom(F::FixedRational)
# Since `den` can be a different type than `T`, this function is used to get the denominator as a `T`.
```

--------------------------------

### Creating Quantities with Macros and Explicit Construction

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/index

Demonstrates creating Quantity objects using the `u"..."` macro for convenience and explicit construction with the `Quantity` type and dimension keywords. It also shows importing units directly.

```julia
julia> x = 0.3u"km/s"
300.0 m s⁻¹

julia> y = 42 * u"kg"
42.0 kg

julia> using DynamicQuantities: kPa

julia> room_temp = 100kPa
100000.0 m⁻¹ kg s⁻²

julia> x = Quantity(300.0, length=1, time=-1)
300.0 m s⁻¹
```

--------------------------------

### User Interface Shortcuts

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/constants

This snippet details the keyboard shortcuts available in the user interface for searching and closing the documentation.

```APIDOC
User Interface:
  - Search: `Ctrl` + `/`
  - Close: `esc`
```

--------------------------------

### Using DynamicQuantities Units

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/units

Demonstrates how to use units from the DynamicQuantities package in Julia code.

```julia
using DynamicQuantities: m

# Example usage with @u_str macro
length_val = 1.5u"m"

# Example usage with explicit import
length_val_explicit = 1.5 * m
```

--------------------------------

### Registering and Using Custom Units

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/index

Demonstrates how to define and register custom units using the `@register_unit` macro and subsequently use them in calculations and conversions.

```julia
julia> @register_unit OneFiveV 1.5u"V"

julia> x = us"OneFiveV"
1.0 OneFiveV

julia> x * 10u"A" |> us"W"
15.0 W

julia> 3us"V" |> us"OneFiveV"
2.0 OneFiveV
```

--------------------------------

### DynamicQuantities.jl API Documentation

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/symbolic_units

This section provides API documentation for the DynamicQuantities.jl package, detailing its various components and functionalities.

```APIDOC
DynamicQuantities.jl API Reference:

- Home: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/
- Examples: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/examples/
- Utilities: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/api/
- Units: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/units/
- Constants: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/constants/
- Symbolic Units: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/symbolic_units/
- Types: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/types/

Version: dev stable v1.7

Source Edit: https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/main/docs/src/symbolic_units.md
```

--------------------------------

### Using Physical Constants

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/index

Shows how to access predefined physical constants from the `Constants` submodule, including defining an alias for easier access and using constants within the `u"..."` macro.

```julia
julia> Constants.c
2.99792458e8 m s⁻¹

julia> const C = Constants

julia> u"Constants.c * Hz"
2.99792458e8 m s⁻²

julia> using DynamicQuantities.Constants: h
```

--------------------------------

### Working with Symbolic Units

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/index

Illustrates the use of symbolic units (`us"..."`) to preserve user-defined units during calculations, and how to expand them to SI base units using `uexpand` or convert between symbolic units using the `|>` operator or `uconvert`.

```julia
julia> q = 100us"cm * kPa"
100.0 cm kPa

julia> q^2
10000.0 cm² kPa²

julia> uexpand(q^2)
1.0e6 kg² s⁻⁴

julia> x = us"Constants.c * Hz"
1.0 Hz c

julia> x^2
1.0 Hz² c²

julia> uexpand(x^2)
8.987551787368176e16 m² s⁻⁴

julia> 5e-9u"m" |> us"nm"
5.0 nm

julia> using DynamicQuantities.SymbolicUnits: cm

julia> using DynamicQuantities.SymbolicConstants: h
```

--------------------------------

### DynamicQuantities.with_type_parameters Function

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/types

Returns the type with specified type parameters instead of the ones in the input type. This is useful for transforming types, like getting `Dimensions{R}` from `(Dimensions{R1}, R)`. Overload for custom type parameter handling.

```APIDOC
DynamicQuantities.with_type_parameters(::Type{<:AbstractDimensions}, ::Type{R})
DynamicQuantities.with_type_parameters(::Type{<:UnionAbstractQuantity}, ::Type{T}, ::Type{D})
```

--------------------------------

### Performance Comparison: DynamicQuantities vs Unitful

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/index

Demonstrates the performance difference between DynamicQuantities.jl and Unitful.jl for calculations where dimensions are not easily inferred by the compiler. DynamicQuantities.jl shows a significant speedup due to its static typing approach.

```julia
using BenchmarkTools, DynamicQuantities; import Unitful

dyn_uni = 0.2u"m/s"
unitful = convert(Unitful.Quantity, dyn_uni)

f(x, i) = x ^ i * 0.3;

@btime f($dyn_uni, 1);
@btime f($unitful, 1);
```

--------------------------------

### DynamicQuantities and Unitful.jl Integration

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/index

Shows how to convert quantities between DynamicQuantities and Unitful.jl. It demonstrates using `convert` to change a Unitful quantity to a DynamicQuantities quantity and vice versa, ensuring compatibility and interoperability between the two packages.

```julia
julia> using Unitful: Unitful, @u_str; import DynamicQuantities

julia> x = 0.5u"km/s"
0.5 km s⁻¹

julia> y = convert(DynamicQuantities.Quantity, x)
500.0 m s⁻¹

julia> y2 = y^2 * 0.3
75000.0 m² s⁻²

julia> x2 = convert(Unitful.Quantity, y2)
75000.0 m² s⁻²

julia> x^2*0.3 == x2
true
```

--------------------------------

### Elementary Calculations with Quantities

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/index

Illustrates basic arithmetic operations (+, -, *, /, ^) and mathematical functions (sqrt, cbrt, abs) supported by Quantity objects, maintaining dimensional integrity.

```julia
julia> x * y
12600.0 m kg s⁻¹

julia> x / y
7.142857142857143 m kg⁻¹ s⁻¹

julia> x ^ 3
2.7e7 m³ s⁻³

julia> x ^ -1
0.0033333333333333335 m⁻¹ s

julia> sqrt(x)
17.320508075688775 m¹ᐟ² s⁻¹ᐟ²

julia> x ^ 1.5
5196.152422706632 m³ᐟ² s⁻³ᐟ²
```

--------------------------------

### DynamicQuantities.jl API Documentation

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/types

This section provides API documentation for DynamicQuantities.jl, detailing its various components and functionalities. It covers types, units, constants, and symbolic dimensions.

```APIDOC
DynamicQuantities.jl API Reference:

Overview:
This API documentation outlines the structure and usage of the DynamicQuantities.jl package, a Julia library for managing physical quantities with units and dimensions.

Key Components:

1.  **Types**
    *   **Symbolic dimensions**: Represents physical dimensions using symbols (e.g., `L` for length, `M` for mass).
        *   Usage: Define and manipulate dimensions symbolically.
    *   **Arrays**: Support for arrays of quantities, enabling operations on collections of physical values.
        *   Usage: Perform element-wise operations with unit-aware arrays.
    *   **Generic quantities**: Abstract representation of quantities that can hold various underlying types and units.
        *   Usage: Create and manage quantities with flexible type and unit handling.
    *   **Custom behavior in abstract quantities**: Allows customization of how abstract quantities interact with other types and functions.
        *   Usage: Extend the functionality of quantities for specific applications.

2.  **Units**
    *   Provides a comprehensive set of predefined physical units.
    *   Supports the creation of custom units.
    *   Enables unit conversions and checks.

3.  **Constants**
    *   Includes definitions for fundamental physical constants.
    *   Constants are associated with their respective units and dimensions.

4.  **Utilities**
    *   Offers various utility functions for working with quantities, units, and dimensions.

Example Usage (Conceptual):
```julia
using DynamicQuantities

# Define a quantity with units
let length = 10.0u"m"
    println(length)
end

# Perform operations
let time = 5.0u"s"
    velocity = length / time
    println(velocity) # Output: 2.0 m s^-1
end

# Accessing dimensions
println(dimension(length)) # Output: u"m"

# Using symbolic dimensions
let mass = 5.0u"kg"
    force = mass * 9.81u"m/s^2"
    println(force) # Output: 49.05 kg m s^-2
    println(dimension(force)) # Output: u"kg m s^-2"
end
```

Related Documentation:
*   [Home](https://ai.damtp.cam.ac.uk/dynamicquantities/dev/)
*   [Examples](https://ai.damdamtp.cam.ac.uk/dynamicquantities/dev/examples/)
*   [Units](https://ai.damtp.cam.ac.uk/dynamicquantities/dev/units/)
*   [Constants](https://ai.damtp.cam.ac.uk/dynamicquantities/dev/constants/)
*   [Symbolic Units](https://ai.damtp.cam.ac.uk/dynamicquantities/dev/symbolic_units/)
```

--------------------------------

### DynamicQuantities.jl API Documentation

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/constants

This section provides API documentation for the DynamicQuantities.jl package. It details the available utilities, units, constants, symbolic units, and types for working with dynamic quantities in Julia.

```APIDOC
DynamicQuantities.jl API Reference:

Utilities:
  Provides various utility functions for dynamic quantities.

Units:
  Defines and manages physical units.

Constants:
  Includes definitions for physical constants, with a subsection for Astronomical constants.

Symbolic Units:
  Supports symbolic representation and manipulation of units.

Types:
  Defines the core data types used within the package for representing dynamic quantities.
```

--------------------------------

### Affine Units (Celsius and Fahrenheit)

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/units

Illustrates the use of affine units like Celsius and Fahrenheit in DynamicQuantities.jl. It shows how to define temperatures using the `ua` string macro and perform operations like finding the difference between temperatures, which are internally converted to Kelvin.

```julia
# Define temperature in Celsius
room_temp = 22ua"degC"    # 295.15 K

# Define temperature in Fahrenheit
freezing = 32ua"degF"     # 273.15 K

# Can take differences normally, as these are now regular Quantities:
room_temp - freezing
```

--------------------------------

### Affine Units in DynamicQuantities

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/index

Demonstrates the use of affine units like Celsius and Fahrenheit with the `ua"..."` macro. These units behave like regular quantities, allowing for operations like taking differences. Conversion back to standard units is shown using `ustrip`.

```julia
julia> room_temp = 22ua"degC"
295.15 K

julia> freezing = 32ua"degF"
273.15 K

julia> ustrip(ua"degC", 295.15u"K")
22.0
```

--------------------------------

### Astronomical Constants in DynamicQuantities

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/constants

This section lists and describes various astronomical constants provided by the DynamicQuantities library. These constants are essential for scientific calculations in astronomy and physics. Each constant includes its definition, measurement standard, and a direct link to its source code in the GitHub repository.

```Julia
DynamicQuantities.Constants.M_earth — Constant
Earth mass. Measured.
[source](https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L165)
```

```Julia
DynamicQuantities.Constants.M_sun — Constant
Solar mass. Measured.
[source](https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L169)
```

```Julia
DynamicQuantities.Constants.M_jup — Constant
Jupiter mass. Measured.
[source](https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L173)
```

```Julia
DynamicQuantities.Constants.R_earth — Constant
Nominal Earth equatorial radius. Standard.
[source](https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L177)
```

```Julia
DynamicQuantities.Constants.R_jup — Constant
Nominal Jupiter equatorial radius. Standard.
[source](https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L181)
```

```Julia
DynamicQuantities.Constants.R_sun — Constant
Nominal solar radius. Standard.
[source](https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L185)
```

```Julia
DynamicQuantities.Constants.L_sun — Constant
Nominal solar luminosity. Standard.
[source](https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L189)
```

```Julia
DynamicQuantities.Constants.L_bol0 — Constant
Standard luminosity at absolute bolometric magnitude 0. Standard.
[source](https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L193)
```

```Julia
DynamicQuantities.Constants.sigma_T — Constant
Thomson scattering cross-section. Measured.
[source](https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L197)
```

```Julia
DynamicQuantities.Constants.au — Constant
Astronomical unit. Standard.
[source](https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L201)
```

```Julia
DynamicQuantities.Constants.pc — Constant
Parsec. Standard.
[source](https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L205)
```

```Julia
DynamicQuantities.Constants.ly — Constant
Light year. Standard.
[source](https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L209)
```

```Julia
DynamicQuantities.Constants.atm — Constant
Standard atmosphere. Standard.
[source](https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L213)
```

--------------------------------

### Physical Constants in DynamicQuantities.jl

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/constants

This section lists and describes various physical constants provided by the DynamicQuantities.jl package. Each constant is linked to its source code and includes a brief description of its physical meaning. These constants are measured values and may have unit restrictions.

```APIDOC
DynamicQuantities.Constants.eps_0
  - Vacuum electric permittivity. Measured.
  - Source: https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L113

DynamicQuantities.Constants.m_e
  - Electron mass. Measured.
  - Source: https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L117

DynamicQuantities.Constants.m_p
  - Proton mass. Measured.
  - Source: https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L121

DynamicQuantities.Constants.m_n
  - Neutron mass. Measured.
  - Source: https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L125

DynamicQuantities.Constants.a_0
  - Bohr radius. Measured.
  - Source: https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L129

DynamicQuantities.Constants.k_e
  - Coulomb constant (Note: SI units only!). Measured.
  - Source: https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L133

DynamicQuantities.Constants.Ryd
  - Rydberg frequency. Measured.
  - Source: https://github.com/JuliaPhysics/DynamicQuantities.jl/blob/725e48d9ff48a477719580e3e7a2eb78d0fb6dcd/src/constants.jl#L137
```

--------------------------------

### Documenter.jl Generation Information

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/constants

This snippet provides details about the Documenter.jl version and the Julia version used during the document generation process. It also includes the date of generation.

```Julia
Documenter.jl version 1.14.1 on Thursday 7 August 2025. Using Julia version 1.11.6.
```

--------------------------------

### QuantityArray Constructors

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/types

Provides various constructors for creating QuantityArray instances. These constructors handle different input types for values and dimensions, including direct dimension specification, inference from quantities, and keyword arguments for dimension types.

```julia
QuantityArray(v::AbstractArray, d::AbstractDimensions)
Create a `QuantityArray` with value `v` and dimensions `d`, using `Quantity` if the eltype of `v` is numeric, and `GenericQuantity` otherwise.
```

```julia
QuantityArray(v::AbstractArray{<:Number}, q::AbstractQuantity)
Create a `QuantityArray` with value `v` and dimensions inferred with `dimension(q)`. This is so that you can easily create an array with the units module, like so: `julia  julia> A = QuantityArray(randn(32), 1u"m")`
```

```julia
QuantityArray(v::AbstractArray{<:Any}, q::AbstractGenericQuantity)
Create a `QuantityArray` with value `v` and dimensions inferred with `dimension(q)`. This is so that you can easily create quantity arrays of non-numeric eltypes, like so: `julia  julia> A = QuantityArray([[1.0], [2.0, 3.0]], GenericQuantity(1u"m"))`
```

```julia
QuantityArray(v::AbstractArray{<:UnionAbstractQuantity})
Create a `QuantityArray` from an array of quantities. This means the following syntax works:```
julia> A = QuantityArray(randn(32) .* 1u"km/s")
```
```

```julia
QuantityArray(v::AbstractArray; kws...)
Create a `QuantityArray` with dimensions inferred from the keyword arguments. For example:```
julia> A = QuantityArray(randn(32); length=1)
```
is equivalent to```
julia> A = QuantityArray(randn(32), u"m")
```
The keyword arguments are passed to `DEFAULT_DIM_TYPE`.
```

--------------------------------

### Custom Dimension Space with Julia Structs

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/index

Demonstrates creating a custom dimension space by defining a Julia struct that subtypes `AbstractDimensions`. This allows for tracking custom physical quantities like 'cookies' and 'milk'.

```julia
struct CookiesAndMilk{R} <: AbstractDimensions{R}
           cookies::R
           milk::R
       end

cookie_rate = Quantity(0.9, CookiesAndMilk(cookies=1, milk=-1))
total_milk = Quantity(103, CookiesAndMilk(milk=1))
total_cookies = cookie_rate * total_milk
```

--------------------------------

### DynamicQuantities Promotion Methods

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/api

Methods for promoting quantity types and dimension types without necessarily promoting the value type. This is useful for operations involving scalar quantities and quantity arrays.

```APIDOC
promote_except_value(q1::UnionAbstractQuantity, q2::UnionAbstractQuantity)

This applies a promotion to the quantity type, and the dimension type, but _not_ the value type. This is necessary because sometimes we would want to multiply a quantity array with a scalar quantity, and wish to use promotion on the quantity type itself, but don't want to promote to a single value type.
```

```APIDOC
promote_quantity_on_quantity(Q1, Q2)

Promotes quantity types Q1 and Q2.
```

--------------------------------

### DynamicQuantities Utilities: ustrip and dimension

Source: https://ai.damtp.cam.ac.uk/dynamicquantities/dev/api

Documentation for the `ustrip` and `dimension` functions in the DynamicQuantities.jl package. `ustrip` removes units from quantities, with variations for handling symbolic dimensions and affine units. `dimension` retrieves the dimensional properties of a quantity.

```APIDOC
DynamicQuantities.ustrip — Function

ustrip(q::AbstractQuantity)
ustrip(q::AbstractGenericQuantity)

Remove the units from a quantity.
Note: If using symbolic dimensions, you might also consider using `ustripexpand` to first convert to SI base units before stripping.

ustrip(unit::UnionAbstractQuantity, q::UnionAbstractQuantity)

Convert quantity `q` to the units specified by `unit`, then strip the units. This is equivalent to `ustrip(q / unit)`, but also verifies the dimensions are compatible.
Examples:
```julia
ustrip(u"km", 1000u"m")
1.0

ustrip(u"s", 1u"minute")
60.0

ustrip(u"km", [1000u"m", 2000u"m"])
2-element Vector{Float64}:
 1.0
 2.0
```

ustrip(unit::AffineUnit, q::UnionAbstractQuantity)

Convert a quantity `q` to the numerical value in terms of affine units specified by `unit`, then strip the units. This allows getting the numerical value in terms of degrees Celsius or Fahrenheit.
Examples:
```julia
ustrip(ua"degC", 27ua"degC")
27.0

ustrip(ua"degF", 300u"K")
80.33000000000003
```

DynamicQuantities.dimension — Function

dimension(q::AbstractQuantity)
dimension(q::AbstractGenericQuantity)
dimension(x)

Get the dimensions of a quantity, returning an `AbstractDimensions` object.
```