--- a/src/Grids/Grids.jl	Mon Feb 03 23:10:12 2025 +0100
+++ b/src/Grids/Grids.jl	Tue Feb 11 08:54:18 2025 +0100
@@ -4,6 +4,26 @@
 using StaticArrays
 using LinearAlgebra
 
+export ParameterSpace
+export HyperBox
+export Simplex
+export Interval
+export Rectangle
+export Box
+export Triangle
+export Tetrahedron
+
+export limits
+export unitinterval
+export unitsquare
+export unitcube
+export unithyperbox
+
+export verticies
+export unittriangle
+export unittetrahedron
+export unitsimplex
+
 # Grid
 export Grid
 export coordinate_size
@@ -45,6 +65,7 @@
 export mapped_grid
 export metric_tensor
 
+include("parameter_space.jl")
 include("grid.jl")
 include("tensor_grid.jl")
 include("equidistant_grid.jl")

--- a/src/Grids/equidistant_grid.jl	Mon Feb 03 23:10:12 2025 +0100
+++ b/src/Grids/equidistant_grid.jl	Tue Feb 11 08:54:18 2025 +0100
@@ -135,21 +135,26 @@
 end
 
 """
-    equidistant_grid(limit_lower::T, limit_upper::T, size::Int)
+    equidistant_grid(limit_lower::Number, limit_upper::Number, size::Int)
 
 Constructs a 1D equidistant grid.
 """
 function equidistant_grid(limit_lower::Number, limit_upper::Number, size::Int)
-    if any(size .<= 0)
+    if size <= 0
         throw(DomainError("size must be postive"))
     end
 
-    if any(limit_upper.-limit_lower .<= 0)
+    if limit_upper-limit_lower <= 0
         throw(DomainError("side length must be postive"))
     end
+
 	return EquidistantGrid(range(limit_lower, limit_upper, length=size)) # TBD: Should it use LinRange instead?
 end
 
+equidistant_grid(d::Interval, size::Int) = equidistant_grid(limits(d)..., size)
+equidistant_grid(hb::HyperBox, dims::Vararg{Int}) = equidistant_grid(limits(hb)..., dims...)
+
+
 CartesianBoundary{D,BID} = TensorGridBoundary{D,BID} # TBD: What should we do about the naming of this boundary?
 
 

--- a/src/Grids/mapped_grid.jl	Mon Feb 03 23:10:12 2025 +0100
+++ b/src/Grids/mapped_grid.jl	Tue Feb 11 08:54:18 2025 +0100
@@ -92,9 +92,8 @@
     )
 end
 
-# TODO: Make sure all methods of `mapped_grid` are implemented correctly and tested.
 """
-    mapped_grid(x, J, size::Vararg{Int})
+    mapped_grid(x, J, size...)
 
 A `MappedGrid` with a default logical grid on the D-dimensional unit hyper 
 box [0,1]ᴰ. `x` and `J` are functions to be evaluated on the logical grid
@@ -102,8 +101,7 @@
 """
 function mapped_grid(x, J, size::Vararg{Int})
     D = length(size)
-        lg = equidistant_grid(ntuple(i->0., D), ntuple(i->1., D), size...) # TODO: Clean this up with ParamaterSpace once feature/grids/manifolds is merged
-    return mapped_grid(x, J, lg)
+    return mapped_grid(x, J, unithyperbox(D), size...)
 end
 
 """
@@ -121,13 +119,13 @@
 end
 
 """
-    mapped_grid(x, J, parameterspace, size)
+    mapped_grid(x, J, ps::ParameterSpace, size...)
 
 A `MappedGrid` with logical grid `lg`. Physical coordinates and Jacobian are
 determined by the functions `x` and `J`.
 """
-function mapped_grid(x, J, parameterspace, size::Vararg{Int})
-    lg = equidistant_grid(parameterspace, size...)
+function mapped_grid(x, J, ps::ParameterSpace, size::Vararg{Int})
+    lg = equidistant_grid(ps, size...)
     return mapped_grid(x, J, lg)
 end
 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/Grids/parameter_space.jl	Tue Feb 11 08:54:18 2025 +0100
@@ -0,0 +1,188 @@
+"""
+    ParameterSpace{D}
+
+A space of parameters of dimension `D`.
+
+Common parameter spaces are created using functions for unit sized spaces
+* [`unitinterval`](@ref)
+* [`unitsquare`](@ref)
+* [`unitcube`](@ref)
+* [`unithyperbox`](@ref)
+* [`unittriangle`](@ref)
+* [`unittetrahedron`](@ref)
+* [`unitsimplex`](@ref)
+
+See also: [`Interval`](@ref), [`HyperBox`](@ref),
+[`Simplex`](@ref).
+"""
+abstract type ParameterSpace{D} end
+Base.ndims(::ParameterSpace{D}) where D = D
+
+"""
+    Interval{T} <: ParameterSpace{1}
+
+A `ParameterSpace` representing an interval.
+"""
+struct Interval{T} <: ParameterSpace{1}
+    a::T
+    b::T
+end
+
+"""
+    Interval(a,b)
+
+An interval with limits `a` and `b`.
+"""
+function Interval(a,b)
+    a, b = promote(a, b)
+    Interval{typeof(a)}(a,b)
+end
+
+"""
+    limits(i::Interval)
+
+The limits of the interval.
+"""
+limits(i::Interval) = (i.a, i.b)
+
+boundary_identifiers(::Interval) = (LowerBoundary(), UpperBoundary())
+
+"""
+    unitinterval(T=Float64)
+
+The interval ``(0,1)``.
+"""
+unitinterval(T=Float64) = Interval(zero(T), one(T))
+
+
+"""
+    HyperBox{T,D} <: ParameterSpace{D}
+
+A `ParameterSpace` representing a hyper box.
+"""
+struct HyperBox{T,D} <: ParameterSpace{D}
+    a::SVector{D,T}
+    b::SVector{D,T}
+end
+
+"""
+    HyperBox(a,b)
+
+A `HyperBox` with lower limits `a` and upper limits `b` for each dimension.
+"""
+function HyperBox(a,b)
+    ET = promote_type(eltype(a),eltype(b))
+    T = SVector{length(a),ET}
+    HyperBox(convert(T,a), convert(T,b))
+end
+
+Rectangle{T} = HyperBox{T,2}
+Box{T} = HyperBox{T,3}
+
+"""
+    limits(box::HyperBox, d)
+
+Limits of `box` along dimension `d`.
+"""
+limits(box::HyperBox, d) = (box.a[d], box.b[d])
+
+"""
+    limits(box::HyperBox)
+
+The lower and upper limits of `box` as tuples.
+"""
+limits(box::HyperBox) = (box.a, box.b)
+
+function boundary_identifiers(box::HyperBox)
+    mapreduce(vcat, 1:ndims(box)) do d
+        [
+            CartesianBoundary{d, LowerBoundary}(),
+            CartesianBoundary{d, UpperBoundary}(),
+        ]
+    end
+end
+
+
+"""
+    unitsquare(T=Float64)
+
+The square limited by 0 and 1 in each dimension.
+"""
+unitsquare(T=Float64) = unithyperbox(T,2)
+
+"""
+    unitcube(T=Float64)
+
+The cube limited by 0 and 1 in each dimension.
+"""
+unitcube(T=Float64) = unithyperbox(T,3)
+
+"""
+    unithyperbox(T=Float64, D)
+
+The hypercube limited by 0 and 1 in each dimension.
+"""
+unithyperbox(T, D) = HyperBox((@SVector zeros(T,D)), (@SVector ones(T,D)))
+unithyperbox(D) = unithyperbox(Float64,D)
+
+
+"""
+    Simplex{T,D,NV} <: ParameterSpace{D}
+
+A `ParameterSpace` representing a simplex.
+"""
+struct Simplex{T,D,NV} <: ParameterSpace{D}
+    verticies::NTuple{NV,SVector{D,T}}
+
+    Simplex(verticies::Tuple{SVector{D,T}, Vararg{SVector{D,T},N}}) where {T,D,N} = new{T,D,N+1}(verticies)
+    Simplex(::Tuple{}) = throw(ArgumentError("Must provide at least one vertex."))
+end
+
+"""
+    Simplex(verticies...)
+
+A simplex with the given verticies.
+"""
+function Simplex(verticies::Vararg{AbstractArray})
+    ET = mapreduce(eltype,promote_type,verticies)
+    T = SVector{length(verticies[1]),ET}
+
+    return Simplex(Tuple(convert(T,v) for v ∈ verticies))
+end
+
+"""
+    verticies(s::Simplex)
+
+Verticies of `s`.
+"""
+verticies(s::Simplex) = s.verticies
+
+Triangle{T} = Simplex{T,2}
+Tetrahedron{T} = Simplex{T,3}
+
+"""
+    unittriangle(T=Float64)
+
+The simplex with verticies ``(0,0)``, ``(1,0)``, and ``(0,1)``.
+"""
+unittriangle(T=Float64) = unitsimplex(T,2)
+
+"""
+    unittetrahedron(T=Float64)
+
+The simplex with verticies ``(0,0,0)``, ``(1,0,0)``, ``(0,1,0)``, and ``(0,0,1)``.
+"""
+unittetrahedron(T=Float64) = unitsimplex(T,3)
+
+"""
+    unitsimplex(T=Float64,D)
+
+The unit simplex in dimension `D` with verticies ``(0,0,0,...)``, ``(1,0,0,...)``, ``(0,1,0,...)``, ``(0,0,1,...)``...
+"""
+function unitsimplex(T,D)
+    z = @SVector zeros(T,D)
+    unitelement = one(eltype(z))
+    verticies = ntuple(i->setindex(z, unitelement, i), D)
+    return Simplex((z,verticies...))
+end
+unitsimplex(D) = unitsimplex(Float64, D)

--- a/test/Grids/equidistant_grid_test.jl	Mon Feb 03 23:10:12 2025 +0100
+++ b/test/Grids/equidistant_grid_test.jl	Tue Feb 11 08:54:18 2025 +0100
@@ -1,6 +1,7 @@
 using Diffinitive.Grids
 using Test
 using Diffinitive.LazyTensors
+using StaticArrays
 
 
 @testset "EquidistantGrid" begin
@@ -153,6 +154,15 @@
             @test [gp[i]...] ≈ [p[i]...] atol=5e-13
         end
     end
+
+    @testset "equidistant_grid(::ParameterSpace)" begin
+        ps = HyperBox((0,0),(2,1))
+
+        @test equidistant_grid(ps, 3,4) == equidistant_grid((0,0), (2,1), 3,4)
+
+        @test equidistant_grid(unitinterval(),3) == equidistant_grid(0,1,3)
+        @test equidistant_grid(HyperBox((0,),(2,)),4) == equidistant_grid(@SVector[0], @SVector[2], 4)
+    end
 end
 
 

--- a/test/Grids/mapped_grid_test.jl	Mon Feb 03 23:10:12 2025 +0100
+++ b/test/Grids/mapped_grid_test.jl	Tue Feb 11 08:54:18 2025 +0100
@@ -278,11 +278,13 @@
     mg = mapped_grid(x̄, J, 10, 11)
     @test mg isa MappedGrid{SVector{2,Float64}, 2}
 
-    lg = equidistant_grid((0,0), (1,1), 10, 11)
+    lg = equidistant_grid(unitsquare(), 10, 11)
     @test logical_grid(mg) == lg
     @test collect(mg) == map(x̄, lg)
 
     @test mapped_grid(x̄, J, lg) == mg
+
+    @test mapped_grid(x̄, J, unitsquare(), 10, 11) == mg
 end
 
 @testset "metric_tensor" begin

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/Grids/parameter_space_test.jl	Tue Feb 11 08:54:18 2025 +0100
@@ -0,0 +1,80 @@
+using Test
+
+using Diffinitive.Grids
+
+@testset "ParameterSpace" begin
+    @test ndims(HyperBox([1,1], [2,2])) == 2
+    @test ndims(unittetrahedron()) == 3
+end
+
+@testset "Interval" begin
+    @test Interval <: ParameterSpace{1}
+
+    @test Interval(0,1) isa Interval{Int}
+    @test Interval(0,1.) isa Interval{Float64}
+
+    @test unitinterval() isa Interval{Float64}
+    @test unitinterval() == Interval(0.,1.)
+    @test limits(unitinterval()) == (0.,1.)
+
+    @test unitinterval(Int) isa Interval{Int}
+    @test unitinterval(Int) == Interval(0,1)
+    @test limits(unitinterval(Int)) == (0,1)
+
+    @test boundary_identifiers(unitinterval()) == (LowerBoundary(), UpperBoundary())
+end
+
+@testset "HyperBox" begin
+    @test HyperBox{<:Any, 2} <: ParameterSpace{2}
+    @test HyperBox([1,1], [2,2]) isa HyperBox{Int, 2}
+
+    @test HyperBox([1,2], [1.,2.]) isa HyperBox{Float64,2}
+
+    @test limits(HyperBox([1,2], [3,4])) == ([1,2], [3,4])
+    @test limits(HyperBox([1,2], [3,4]), 1) == (1,3)
+    @test limits(HyperBox([1,2], [3,4]), 2) == (2,4)
+
+    @test unitsquare() isa HyperBox{Float64,2}
+    @test limits(unitsquare()) == ([0,0],[1,1])
+
+    @test unitcube() isa HyperBox{Float64,3}
+    @test limits(unitcube()) == ([0,0,0],[1,1,1])
+
+    @test unithyperbox(4) isa HyperBox{Float64,4}
+    @test limits(unithyperbox(4)) == ([0,0,0,0],[1,1,1,1])
+
+
+    @test boundary_identifiers(unitsquare()) == [
+        CartesianBoundary{1,LowerBoundary}(),
+        CartesianBoundary{1,UpperBoundary}(),
+        CartesianBoundary{2,LowerBoundary}(),
+        CartesianBoundary{2,UpperBoundary}(),
+    ]
+
+    @test boundary_identifiers(unitcube()) == [
+        CartesianBoundary{1,LowerBoundary}(),
+        CartesianBoundary{1,UpperBoundary}(),
+        CartesianBoundary{2,LowerBoundary}(),
+        CartesianBoundary{2,UpperBoundary}(),
+        CartesianBoundary{3,LowerBoundary}(),
+        CartesianBoundary{3,UpperBoundary}(),
+    ]
+end
+
+@testset "Simplex" begin
+    @test Simplex{<:Any, 3} <: ParameterSpace{3}
+    @test Simplex([1,2], [3,4]) isa Simplex{Int, 2}
+    @test Simplex([1,2,3], [4,5,6],[1,1,1]) isa Simplex{Int, 3}
+
+    @test Simplex([1,2], [3.,4.]) isa Simplex{Float64, 2}
+
+    @test verticies(Simplex([1,2], [3,4])) == ([1,2], [3,4])
+
+    @test unittriangle() isa Simplex{Float64,2}
+    @test verticies(unittriangle()) == ([0,0], [1,0], [0,1])
+
+    @test unittetrahedron() isa  Simplex{Float64,3}
+    @test verticies(unittetrahedron()) == ([0,0,0], [1,0,0], [0,1,0],[0,0,1])
+
+    @test unitsimplex(4) isa Simplex{Float64,4}
+end