Add @licioromao 's changes to read more POMDPFIle formats

.github/workflows/CI.yml

@@ -7,16 +7,25 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - uses: julia-actions/setup-julia@v1
         with:
           version: '1'
           arch: x64
+      - name: Set up SSH
+        uses: webfactory/[email protected]
+        with:
+          ssh-private-key: ${{ secrets.SSH_PRIVATE_KEY }} 
+      - name: Adding WildcardArrays
+        run: | 
+          julia --project -e 'using Pkg; Pkg.add(PackageSpec(url="[email protected]:licioromao/WildcardArrays.jl.git")); Pkg.instantiate()'
       - uses: julia-actions/julia-buildpkg@v1
       - uses: julia-actions/julia-runtest@v1
       - uses: julia-actions/julia-processcoverage@v1
-      - uses: codecov/codecov-action@v1
+      - uses: actions/checkout@master
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v1
         with:
           file: ./lcov.info
           flags: unittests
-          name: codecov-umbrella
+          name: codecov-umbrellav 

.github/workflows/CompatHelper.yml

@@ -24,3 +24,5 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           COMPATHELPER_PRIV: ${{ secrets.DOCUMENTER_KEY }}
           # COMPATHELPER_PRIV: ${{ secrets.COMPATHELPER_PRIV }}
+
+

.gitignore

@@ -1,4 +1,11 @@
 *.jl.cov
 *.jl.*.cov
 *.jl.mem
-Manifest.toml
+Manifest.toml
+scripts/
+
+
+test/sources/txt-files/
+test/sources/ejs/txt-files/
+test/sources/cheng-examples/txt-files/
+.*.swp

Project.toml

@@ -1,27 +1,29 @@
 name = "POMDPFiles"
 uuid = "9cf5b727-2e06-5671-8c87-8c6b0f729d5d"
 repo = "https://github.com/JuliaPOMDP/POMDPFiles.jl"
-version = "0.2.4"
+version = "0.3.0"
 
 [deps]
-POMDPModels = "355abbd5-f08e-5560-ac9e-8b5f2592a0ca"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 POMDPTools = "7588e00f-9cae-40de-98dc-e0c70c48cdd7"
 POMDPXFiles = "c6f6ee83-58c6-5336-a19f-2c76817e1af6"
 POMDPs = "a93abf59-7444-517b-a68a-c42f96afdd7d"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
+WildcardArrays = "05d16eb0-506c-4fac-9187-f7ce7e253b09"
 
 [compat]
 POMDPTools = "0.1.4"
 POMDPXFiles = "0.2"
 POMDPs = "0.9"
 Reexport = "0.2, 1"
-julia = "1"
+WildcardArrays = "0.1.0"
+julia = "1.6"
 
 [extras]
 Downloads = "f43a241f-c20a-4ad4-852c-f6b1247861c6"
-Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 SHA = "ea8e919c-243c-51af-8825-aaa63cd721ce"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
 test = ["Downloads", "Test", "SHA"]

README.md

@@ -1,6 +1,85 @@
 # POMDPFiles
+[![Build Status](https://github.com/licioromao/POMDPFiles.jl/actions/workflows/CI.yml/badge.svg?branch=main)](https://github.com/licioromao/POMDPFiles.jl/actions/workflows/CI.yml?query=branch%3Amain)
+[![codecov](https://codecov.io/gh/licioromao/POMDPFiles.jl/branch/main/graph/badge.svg?token=btTBnBTQyw)](https://codecov.io/gh/licioromao/POMDPFiles.jl)
 
-[![Build Status](https://github.com/JuliaPOMDP/POMDPFiles.jl/actions/workflows/CI.yml/badge.svg)](https://github.com/JuliaPOMDP/POMDPFiles.jl/actions/workflows/CI.yml/)
-[![codecov](https://codecov.io/gh/JuliaPOMDP/POMDPFiles.jl/branch/master/graph/badge.svg?token=6pQE1gHKIz)](https://codecov.io/gh/JuliaPOMDP/POMDPFiles.jl)
+<!-- [![Build Status](https://github.com/licioromao/POMDPFiles.jl/actions/workflows/CI.yml/bagde.svg)](https://github.com/licioromao/POMDPFiles.jl/actions/workflows/CI.yml/) -->
 
-Writes POMDP files (https://www.pomdp.org/code/pomdp-file-spec.html) for use in [POMDPSolve.jl](https://github.com/JuliaPOMDP/POMDPSolve.jl) from [POMDPs.jl models](https://github.com/JuliaPOMDP/POMDPs.jl).
+This package constitutes the interface between the [POMDPs.jl](https://github.com/JuliaPOMDP/POMDPs.jl) package and the file format .pomdp defined in [POMDP.org](https://www.pomdp.org/code/pomdp-file-spec.html).
+
+## Installation 
+
+Please use the following command to use this package
+```julia
+] add [email protected]:licioromao/POMDPFiles.jl.git
+```
+## API
+
+```julia
+WildcardArrayPOMDP(s::Int, a::Int, o::Int, initial_state::InitialStateParam, discount::Float64, T::WildcardArray{Float64, 3}, O::WildcardArray{Float64, 3}, R::WildcardArray{Float64, 4})
+
+WildcardArrayPOMDP(filename::String)
+```
+
+Constructors for the `WilcardArrayPOMDP`. We allow the user to create this type either through a .POMDP file format or specifying manually the number of actions, initial distribution, and transitions using the type [WildcardArrays]([email protected]:sisl/WildcardArrays.jl.git). The API for the InitialStateParam is described below.
+
+```julia
+SWildcardArrayPOMDP(filename::String) 
+
+statenames(m::SWildcardArrayPOMDP) 
+actionnames(m::SWildcardArrayPOMDP) 
+obsnames(m::SWildcardArrayPOMDP) 
+```
+
+To deal with pomdp specifications where states, actions, and observations are specified with strings, i.e., `ss = ["warm", "very-warm"], aa = ["north", "west", "east", "west"]`, one may use the SWildcardArrayPOMDP type. More details on the differences between these two types are presented below. Three methods, `statenames`, `actionnames`, and `obsnames`, are defined to retrieve the names associated with the corresponding field of an `SWildcardArrayPOMDP` type.  
+
+> **Warning:** Functions `statenames`, `actionnames`, `obsnames` are not implemented for a `WildcardArrayPOMDP` type. 
+
+```julia
+mutable struct InitialStateParam
+    number::Int
+    type_of_distribution::String
+    support_of_distribution::Set{Int}
+    value_of_distribution::Vector{Float64}
+
+end
+InitialStateParam(number::Int) = InitialStateParam(number, " ", Set{Int}([]), Vector{Float64}([])) 
+InitialStateParam() = InitialStateParam(0)
+```
+
+This is interface used to define the initial distribution of `WildcardArrayPOMDP`. It contains information about the number of states, support of the distribution, and a probability vector representation the initial distribution. The parameter `type_of_distribution` can either be equal to `"uniform"` or `"general distribution"`.
+
+<!-- TODO: Try to add a more complex example here -->
+## Quick example
+
+In the example below we download the *paint.95.POMDP* file from [POMDP.org](https://www.pomdp.org/examples/paint.95.POMDP) and parse the content into a `SWildcardArrayPOMDP` variable type defined in this package. We then illustrate a few functionalities from *POMDPs.jl*.
+
+```julia
+using HTTP, POMDPs, POMDPFiles
+
+mktempdir() do tmp_dir 
+    url = "https://www.pomdp.org/examples/paint.95.POMDP"
+    tmp_file_name = joinpath(tmp_dir, "paint.95.POMDP")
+    HTTP.download(url, tmp_file_name)
+
+    pomdp = SWildcardArrayPOMDP(tmp_file_name)
+
+    states(pomdp)
+end
+```
+Some of the examples in [POMDP.org](https://www.pomdp.org/examples), for instance, the `mini-hall2`, specifies a POMDP without associating names with states, actions, and observations. In these cases, one may use the `WildcardArrayPOMDP` type as described in the example below. 
+
+```julia
+using HTTP, POMDPs, POMDPFiles
+
+mktempdir() do tmp_dir 
+    url = "https://www.pomdp.org/examples/mini-hall2.POMDP"
+    tmp_file_name = joinpath(tmp_dir, "mini-hall2.POMDP")
+    HTTP.download(url, tmp_file_name)
+
+    pomdp = WildcardArrayPOMDP(tmp_file_name)
+
+    initialstate(pomdp)
+end
+```
+
+Using `SWildcardArrayPOMDP` in the previous example would allow us to refer to states, actions, and observations by means of a $0$-based indexing.

src/POMDPFiles.jl

@@ -4,13 +4,21 @@ using Reexport
 using POMDPs
 using POMDPTools
 using Printf
-using POMDPModels: TabularPOMDP
+using WildcardArrays
+using WildcardArrays: WildcardArray
+using LinearAlgebra
 
 @reexport using POMDPXFiles # for POMDPAlphas
 
-import POMDPs: action, value
+import POMDPs: transition, reward, discount, observation, states, stateindex, actions, actionindex, observations, obsindex, initialstate 
 
-export read_alpha, read_pomdp
+export InitialStateParam
+include("types.jl")
+
+export WildcardArrayPOMDP, SWildcardArrayPOMDP, statenames, actionnames, obsnames 
+include("WildcardArrayPOMDPs.jl")
+
+export read_alpha, read_pomdp 
 include("reader.jl")
 
 export numericprint, symbolicprint

src/WildcardArrayPOMDPs.jl

@@ -0,0 +1,146 @@
+"""
+    WildcardArrayPOMDP is the main data structure of the package. It is used to represent a POMDP problem from a file.
+
+        ns: number of states
+        na: number of actions
+        no: number of observations
+
+        support_initialstate: support of the initial state distribution
+        initialstate_distribution: initial state distribution
+
+        discount: discount factor
+
+        T: transition matrix
+        O: observation matrix
+        R: reward matrix
+"""
+struct WildcardArrayPOMDP <: POMDP{Int, Int, Int} 
+    ns::Int
+    na::Int
+    no::Int
+
+    support_initialstate::Set{Int}
+    initialstate_distribution::Vector{Float64}
+
+    discount::Float64
+
+    T::WildcardArray{Float64, 3}
+    O::WildcardArray{Float64, 3}
+    R::WildcardArray{Float64, 4}
+end
+
+"""
+    Constructors for the WildcardArrayPOMDP type.
+"""
+WildcardArrayPOMDP(s::Int, a::Int, o::Int, initial_state::InitialStateParam, discount::Float64, T::WildcardArray{Float64, 3}, O::WildcardArray{Float64, 3}, R::WildcardArray{Float64, 4})= WildcardArrayPOMDP(s, a, o, support(initial_state), prob(initial_state), discount, T, O, R)  
+WildcardArrayPOMDP(filename::String) = read_pomdp(filename; output=:WildcardArrayPOMDP)
+
+"""
+        Implementing the functions required by the POMDP interface. See [POMDPs.jl](https://juliapomdp.github.io/POMDPs.jl/latest/) for more details on the interface.
+"""
+states(m::WildcardArrayPOMDP) = 1:m.ns
+stateindex(m::WildcardArrayPOMDP, i::Int) = (i <= m.ns) ? i : error("Querying states outside the allowable range.")
+
+actions(m::WildcardArrayPOMDP) = 1:m.na
+actionindex(m::WildcardArrayPOMDP, i::Int) = (i <= m.na) ? i : error("Querying input outside the allowable range.")
+
+observations(m::WildcardArrayPOMDP) = 1:m.no
+obsindex(m::WildcardArrayPOMDP, i::Int) = (i <= m.no) ? i : error("Querying observations outside the allowable range.")
+
+function initialstate(m::WildcardArrayPOMDP)
+    if !isempty(m.initialstate_distribution)
+        return SparseCat(states(m), m.initialstate_distribution)
+    else
+        return SparseCat(states(m), 1/m.ns*ones(m.ns))
+    end
+end
+
+function transition(m::WildcardArrayPOMDP, s::Int, a::Int)
+    prob_val = [m.T[a,s,sp] for sp in states(m)]
+    return SparseCat(states(m), prob_val)
+end
+
+function observation(m::WildcardArrayPOMDP, a::Int, sp::Int)
+    prob_obs = [m.O[a, sp, obs] for obs in observations(m)]
+    return SparseCat(observations(m), prob_obs)
+end
+
+reward(m::WildcardArrayPOMDP, s::Int, a::Int, sp::Int, obs::Int) = m.R[a,s,sp,obs]
+reward(m::WildcardArrayPOMDP, s::Int, a::Int, sp::Int) = m.R[a,s,sp,1]
+reward(m::WildcardArrayPOMDP, s::Int, a::Int) = m.R[a,s,1,1]
+
+discount(m::WildcardArrayPOMDP) = m.discount
+
+# Data structure with names
+"""
+    SWildcardArrayPOMDP is used whenever the names of the states, actions, and observations are known. It is used to represent a POMDP problem from a file.
+
+        dic_states: dictionary with the names of the states
+        dic_actions: dictionary with the names of the actions
+        dic_obs: dictionary with the names of the observations
+        pomdp: WildcardArrayPOMDP structure
+"""
+struct SWildcardArrayPOMDP <: POMDP{String, String, String}
+    dic_states::Dict{String, Int}
+    dic_actions::Dict{String, Int}
+    dic_obs::Dict{String, Int}
+    pomdp::WildcardArrayPOMDP
+
+    function SWildcardArrayPOMDP(dic_ss::Dict{String, Int}, dic_aa::Dict{String, Int}, dic_oo::Dict{String, Int}, pomdp::WildcardArrayPOMDP)
+        @assert length(dic_ss) == pomdp.ns
+        @assert length(dic_aa) == pomdp.na
+        @assert length(dic_oo) == pomdp.no
+
+        new(dic_ss, dic_aa, dic_oo, pomdp)
+    end
+end
+SWildcardArrayPOMDP(filename::String) = read_pomdp(filename; output=:SWildcardArrayPOMDP)
+"""
+    Implementing the functions required by the POMDP interface. See [POMDPs.jl](https://juliapomdp.github.io/POMDPs.jl/latest/) for more details on the interface.
+"""
+states(m::SWildcardArrayPOMDP) = states(m.pomdp)
+stateindex(m::SWildcardArrayPOMDP, key::Int) = stateindex(m.pomdp, key)
+statenames(m::SWildcardArrayPOMDP) = collect(keys(m.dic_states))
+function stateindex(m::SWildcardArrayPOMDP, key::String) 
+    i = m.dic_states[key]
+    return stateindex(m, i)
+end
+
+actions(m::SWildcardArrayPOMDP) = actions(m.pomdp)
+actionindex(m::SWildcardArrayPOMDP, key::Int) = actionindex(m.pomdp, key)
+actionnames(m::SWildcardArrayPOMDP) = collect(keys(m.dic_actions))
+function actionindex(m::SWildcardArrayPOMDP, key::String)
+    i = m.dic_actions[key]
+    return actionindex(m, i)
+end
+
+observations(m::SWildcardArrayPOMDP) = observations(m.pomdp)
+obsindex(m::SWildcardArrayPOMDP, i::Int) = obsindex(m.pomdp, i) 
+obsnames(m::SWildcardArrayPOMDP) = collect(keys(m.dic_obs))
+function obsindex(m::SWildcardArrayPOMDP, key::String)
+    i = m.dic_obs[key]
+    return obsindex(m, i)
+end
+
+initialstate(m::SWildcardArrayPOMDP) = initialstate(m.pomdp)
+
+transition(m::SWildcardArrayPOMDP, s::Int, a::Int) = transition(m.pomdp, s, a)
+function transition(m::SWildcardArrayPOMDP, s::String, a::String)
+   is = m.dic_states[s]; ia = m.dic_actions[a] 
+   return transition(m, is, ia)
+end
+
+observation(m::SWildcardArrayPOMDP, a::Int, sp::Int) = observation(m.pomdp, a, sp)
+function observation(m::SWildcardArrayPOMDP, a::String, sp::String)
+    isp = m.dic_states[sp]; ia = m.dic_actions[a] 
+    return observation(m, ia, isp) 
+end
+
+reward(m::SWildcardArrayPOMDP, s::Int, a::Int, sp::Int, obs::Int) = reward(m.pomdp, s, a, sp, obs)
+reward(m::SWildcardArrayPOMDP, s::String, a::String, sp::String, obs::String) = reward(m.pomdp, m.dic_states[s], m.dic_actions[a], m.dic_states[sp], m.dic_obs[obs])
+reward(m::SWildcardArrayPOMDP, s::Int, a::Int, sp::Int) = reward(m.pomdp, s, a, sp)
+reward(m::SWildcardArrayPOMDP, s::String, a::String, sp::String) = reward(m.pomdp, m.dic_states[s], m.dic_actions[a], m.dic_states[sp])
+reward(m::SWildcardArrayPOMDP, s::Int, a::Int) = reward(m.pomdp, s, a)
+reward(m::SWildcardArrayPOMDP, s::String, a::String) = reward(m.pomdp, m.dic_states[s], m.dic_actions[a])
+
+discount(m::SWildcardArrayPOMDP) = discount(m.pomdp)