update README.md

Author: findmyway

Project.toml

@@ -6,6 +6,7 @@ version = "0.1.0"
 [deps]
 FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"
 IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 

README.md

@@ -13,25 +13,64 @@
 
 |Category|Style|Example|
 |:---|:----|:-----|
-|Enumerable discrete space| `DiscreteSpaceStyle{2, ()}()` | `Space((:cat, :dog))`, `Space(0:1)`, `Space(1:2)`, `Space(Bool)`|
-|Multi-dimensional discrete space| `DiscreteSpaceStyle{2, (3,4)}()` | `Space((:cat, :dog), 3, 4)`, `Space(0:1, 3, 4)`, `Space(1:2, 3, 4)`, `Space(Bool, 3, 4)`|
-|Multi-dimensional variable discrete space| `DiscreteSpaceStyle{(2,)}()` | `Space(SVector((:cat, :dog), (:litchi, ：longan, ：mango))`, `Space([-1:1, (false, true)])`|
-|Continuous space| `ContinuousSpaceStyle()` | `Space(-1.2..3.3)`, `Space(Float32)`|
+|Enumerable discrete space| `DiscreteSpaceStyle{()}()` | `Space((:cat, :dog))`, `Space(0:1)`, `Space(1:2)`, `Space(Bool)`|
+|Multi-dimensional discrete space| `DiscreteSpaceStyle{(3,4)}()` | `Space((:cat, :dog), 3, 4)`, `Space(0:1, 3, 4)`, `Space(1:2, 3, 4)`, `Space(Bool, 3, 4)`|
+|Multi-dimensional variable discrete space| `DiscreteSpaceStyle{(2,)}()` | `Space(SVector((:cat, :dog), (:litchi, :longan, :mango))`, `Space([-1:1, (false, true)])`|
+|Continuous space| `ContinuousSpaceStyle{()}()` | `Space(-1.2..3.3)`, `Space(Float32)`|
 |Multi-dimensional continuous space| `ContinuousSpaceStyle{(3,4)}()` | `Space(-1.2..3.3, 3, 4)`, `Space(Float32, 3, 4)`|
 
 ### API
 
-### Size Info
-
 ```julia
-```
+julia> s = Space((:litchi, :longan, :mango))
+Space{Tuple{Symbol, Symbol, Symbol}}((:litchi, :longan, :mango))
 
-#### Sampling
+julia> rand(s)
+:litchi
 
-```julia
-```
+julia> rand(s) in s
+true
 
-### Existence Checking
+julia> size(s)
+()
+```
 
 ```julia
+julia> using CommonRLSpaces
+
+julia> s = Space(UInt8, 2,3)
+Space{Matrix{UnitRange{UInt8}}}(UnitRange{UInt8}[0x00:0xff 0x00:0xff 0x00:0xff; 0x00:0xff 0x00:0xff 0x00:0xff])
+
+julia> rand(s)
+2×3 Matrix{UInt8}:
+ 0x7b  0x38  0xf3
+ 0x6a  0xe1  0x28
+
+julia> rand(s) in s
+true
+
+julia> SpaceStyle(s)
+DiscreteSpaceStyle{(2, 3)}()
+
+julia> size(s)
+(2, 3)
 ```
+
+```julia
+julia> s = Space(SVector(-1..1, 0..1))
+Space{SVector{2, ClosedInterval{Int64}}}(ClosedInterval{Int64}[-1..1, 0..1])
+
+julia> rand(s)
+2-element SVector{2, Float64} with indices SOneTo(2):
+ 0.5563101538643473
+ 0.9227368869418011
+
+julia> rand(s) in s
+true
+
+julia> SpaceStyle(s)
+ContinuousSpaceStyle{(2,)}()
+
+julia> size(s)
+(2,)
+```

src/CommonRLSpaces.jl

@@ -5,6 +5,7 @@ using Reexport
 @reexport using FillArrays
 @reexport using IntervalSets
 @reexport using StaticArrays
+@reexport import Base: OneTo
 
 include("basic.jl")
 

src/basic.jl

@@ -1,3 +1,74 @@
+export Space, SpaceStyle, DiscreteSpaceStyle, ContinuousSpaceStyle
+
+using Random
+
 struct Space{T}
     s::T
 end
+
+Space(s::Type{T}) where {T} = Space(typemin(T):typemax(T))
+
+Space(x, dims::Int...) = Space(fill(x, dims))
+Space(x::Type{T}, dims::Int...) where {T<:Integer} = Space(fill(typemin(x):typemax(T), dims))
+Space(x::Type{T}, dims::Int...) where {T<:AbstractFloat} = Space(fill(typemin(x) .. typemax(T), dims))
+
+const TupleSpace = Tuple{Vararg{<:Space}}
+const NamedSpace = NamedTuple{<:Any,<:TupleSpace}
+const DictSpace = Dict{<:Any,<:Space}
+
+Base.size(s::Space) = size(SpaceStyle(s))
+
+#####
+
+abstract type AbstractSpaceStyle{S} end
+
+Base.size(::AbstractSpaceStyle{S}) where {S} = S
+
+struct DiscreteSpaceStyle{S} <: AbstractSpaceStyle{S} end
+struct ContinuousSpaceStyle{S} <: AbstractSpaceStyle{S} end
+
+SpaceStyle(::Space{<:Tuple}) = DiscreteSpaceStyle{()}()
+SpaceStyle(::Space{<:AbstractRange}) = DiscreteSpaceStyle{()}()
+SpaceStyle(::Space{<:AbstractInterval}) = ContinuousSpaceStyle{()}()
+
+SpaceStyle(s::Space{<:AbstractArray{<:Tuple}}) = DiscreteSpaceStyle{size(s.s)}()
+SpaceStyle(s::Space{<:AbstractArray{<:AbstractRange}}) = DiscreteSpaceStyle{size(s.s)}()
+SpaceStyle(s::Space{<:AbstractArray{<:AbstractInterval}}) = ContinuousSpaceStyle{size(s.s)}()
+
+#####
+
+Random.rand(rng::Random.AbstractRNG, s::Space) = rand(rng, s.s)
+
+Random.rand(
+    rng::Random.AbstractRNG,
+    s::Union{
+        <:Space{<:AbstractArray{<:Tuple}},
+        <:Space{<:AbstractArray{<:AbstractRange}},
+        <:Space{<:AbstractArray{<:AbstractInterval}}
+    }
+) = map(x -> rand(rng, x), s.s)
+
+Base.in(x, s::Space) = x in s.s
+
+Base.in(
+    x,
+    s::Union{
+        <:Space{<:AbstractArray{<:Tuple}},
+        <:Space{<:AbstractArray{<:AbstractRange}},
+        <:Space{<:AbstractArray{<:AbstractInterval}}
+    }
+) = size(x) == size(s) && all(x -> x[1] in x[2], zip(x, s.s))
+
+function Random.rand(rng::AbstractRNG, s::Interval{:closed,:closed,T}) where {T}
+    if s == typemin(T) .. typemax(T)
+        rand(T)
+    else
+        r = rand(rng)
+
+        if r == 0.0
+            r = rand(Bool)
+        end
+
+        r * (s.right - s.left) + s.left
+    end
+end

test/runtests.jl

@@ -2,5 +2,36 @@ using CommonRLSpaces
 using Test
 
 @testset "CommonRLSpaces.jl" begin
-    # Write your tests here.
+    s1 = Space((:cat, :dog))
+    @test :cat in s1
+    @test !(nothing in s1)
+
+    s2 = Space(0:1)
+    @test 0 in s2
+    @test !(0.5 in s2)
+
+    s3 = Space(Bool)
+    @test false in s3
+    @test true in s3
+
+    s4 = Space(Float64)
+    @test rand() in s4
+    @test 0 in s4
+
+    s5 = Space(Float64, 3, 4)
+    @test rand(3, 4) in s5
+
+    s6 = Space(SVector((:cat, :dog), (:litchi, :longan, :mango)))
+    @test SVector(:dog, :litchi) in s6
+
+    s7 = Space([-1 .. 1, 2 .. 3])
+    @test [0, 2] in s7
+    @test !([-5, 5] in s7)
+
+    # for _ in 1:100
+    for s in [s1, s2, s3, s4, s5, s6, s7]
+        @info s
+        @test rand(s) in s
+    end
+    # end
 end