demuu 0.1.0__tar.gz

demuu-0.1.0/LICENCE

@@ -0,0 +1,19 @@
+Copyright (c) <year> Guillaume Lozenguez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

demuu-0.1.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: demuu
+Version: 0.1.0
+Summary: Python wrap of libDemuu
+Author-email: Guillaume Lozenguez <guillaume@ktorz.net>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+License-File: LICENCE
+Project-URL: Homepage, https://ktorz-net.github.io/pyDemuu
+
+# pyDemuu - DeMUU Python Library
+
+The DeMUU project aims to implement models and algorythms for Decision-Majing Under Uncertainty. 
+Devellopement is based on multiple discrete variables defined Markov Decision Process with a transition function defined as a Bayesian network.
+
+_pyDemuu_ is mainly a Python wrapper of the _libDemuu_ (_C_ librairy).
+It also introduces some user-friendly Python classes to better manage _DeMUU_ concepts.
+
+## Install
+
+**Attention:** Actually, only `x86` machin under `Linux` OS are supported.
+
+```sh
+pip install demuu
+```
+
+## Links 
+
+- Python wrapper on github : [pyDeMUU](https://github.com/ktorz-net/pydemuu)
+- Documentation : [libDeMUU](https://github.com/ktorz-net/libdemuu)
+- C Librairy on github : [ktorz-net.github.io](https://ktorz-net.github.io)
+

demuu-0.1.0/docs/pypip-index.md

@@ -0,0 +1,21 @@
+# pyDemuu - DeMUU Python Library
+
+The DeMUU project aims to implement models and algorythms for Decision-Majing Under Uncertainty. 
+Devellopement is based on multiple discrete variables defined Markov Decision Process with a transition function defined as a Bayesian network.
+
+_pyDemuu_ is mainly a Python wrapper of the _libDemuu_ (_C_ librairy).
+It also introduces some user-friendly Python classes to better manage _DeMUU_ concepts.
+
+## Install
+
+**Attention:** Actually, only `x86` machin under `Linux` OS are supported.
+
+```sh
+pip install demuu
+```
+
+## Links 
+
+- Python wrapper on github : [pyDeMUU](https://github.com/ktorz-net/pydemuu)
+- Documentation : [libDeMUU](https://github.com/ktorz-net/libdemuu)
+- C Librairy on github : [ktorz-net.github.io](https://ktorz-net.github.io)

demuu-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["flit_core >= 3.4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "demuu"
+version = "0.1.0"
+authors = [
+  { name="Guillaume Lozenguez", email="guillaume@ktorz.net" },
+]
+description = "Python wrap of libDemuu"
+readme = "docs/pypip-index.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[tool.flit.module]
+name = "demuu"
+
+[project.urls]
+Homepage = "https://ktorz-net.github.io/pyDemuu"

demuu-0.1.0/src/demuu/__init__.py

@@ -0,0 +1,4 @@
+# Demuu friendly API :
+from .model import Node, Model
+
+#Reward= model.Node

demuu-0.1.0/src/demuu/clib/__init__.py

@@ -0,0 +1,18 @@
+# Core LibDemuu Wraps:
+
+## LibDemuu :: STRUCTURE MODULE :
+from .code import Code
+from .vector import Vector
+from .bench import Bench
+from .tree import Tree
+
+## LibDemuu :: FUNCTION MODULE :
+from .valuefct import ValueFct
+from .function import Function
+
+## LibDemuu :: COMPONENT MODULE :
+from .condition import Condition
+from .dynamic import Dynamic
+from .evaluator import Evaluator
+
+## LibDemuu :: SOLVER MODULE :

demuu-0.1.0/src/demuu/clib/bench.py

@@ -0,0 +1,112 @@
+from . import clibdemuu as cc
+from .clibdemuu import c_digit, c_double
+from .code import Code
+from .vector import Vector
+
+# DuBench wrap:
+class Bench :
+    # Construction destruction:
+    def __init__(self, aListOfTuples=[], capacity= 16, cbench= None):
+        if cbench is None :
+            capacity= max( capacity, len(aListOfTuples) )
+            self._cbench= cc.newDuBench( c_digit(capacity) )
+            for codeList, v in aListOfTuples :
+                if type(v) is list :
+                    self.attachLast( Code( codeList ), Vector( v ) )
+                else :
+                    self.attachLast( Code( codeList ), Vector( [v] ) )
+            self._cmaster= True
+        else: 
+            self._cbench= cbench
+            self._cmaster= False
+    
+    def __del__(self):
+        if self._cmaster :
+            cc.deleteDuBench( self._cbench )
+    
+    def initialize( self, aListOfTuples=[], capacity= 16 ):
+        capacity= max( capacity, len(aListOfTuples) )
+        cc.DuBench_reinit( self._cbench, c_digit(capacity) )
+        for codeList, vectorList in aListOfTuples :
+            self.attachLast( Code( codeList ), Vector( vectorList ) )
+        return self
+            
+    # Accessor
+    def size( self ):
+        return cc.DuBench_size( self._cbench )
+    
+    def codeAt(self, i):
+        return Code( ccode= cc.DuBench_codeAt( self._cbench, c_digit(i) ) )
+    
+    def vectorAt( self, i ):
+        return Vector( cvector=cc.DuBench_vectorAt( self._cbench, c_digit(i) ) )
+
+    def digitAt( self, i ):
+        return cc.DuBench_digitAt( self._cbench, c_digit(i) )
+    
+    def valueAt( self, i ):
+        return cc.DuBench_valueAt( self._cbench, c_digit(i) )
+    
+    def range(self):
+        return range(1, self.size()+1)
+    
+    def asCodeValueList( self ):
+        return [ (self.codeAt(i).asList(), self.valueAt(i)) for i in self.range() ]
+    
+    def asList( self ):
+        return [ (self.codeAt(i).asList(), self.vectorAt(i).asList() ) for i in self.range() ]
+    
+    # Construction
+    def attachLast( self, newCode, newVector ):
+        assert newCode._cmaster 
+        cc.DuBench_attachCode_vector(
+            self._cbench,
+            newCode._ccode,
+            newVector._cvector )
+        newCode._cmaster= False
+        newVector._cmaster= False
+    
+    def detachLast( self ):
+        code= Code( ccode= cc.DuBench_detach( self._cbench ) )
+        code._cmaster= True
+        return code
+
+    def attachFirst( self, newCode, newVector ):
+        assert newCode._cmaster 
+        cc.DuBench_attachFrontCode_vector(
+            self._cbench,
+            newCode._ccode,
+            newVector._cvector )
+        newCode._cmaster= False
+        newVector._cmaster= False
+    
+    def detachFirst( self ):
+        code= Code( ccode= cc.DuBench_detachFront( self._cbench ) )
+        code._cmaster= True
+        return code
+
+    def at_setValue(self, i, value):
+        cpointer= cc.DuBench_at_setValue(
+                        self._cbench,
+                        c_digit(i),
+                        c_double(value)
+        )
+        return Code( ccode= cpointer )
+
+    # dump and load:
+    def dump(self):
+        descriptor= self.asList()
+        return descriptor
+    
+    def load(self, descriptor):
+        return self.initialize( descriptor )
+    
+    # Print 
+    def __str__(self):
+        size= self.size()
+        if size == 0 :
+            return "bench[]"
+        s= "bench["+ str( self.codeAt(1).asList() ) +":"+ str( self.vectorAt(1).asList() )
+        for i in range(2, size+1) :
+            s+= ", "+ str( self.codeAt(i).asList() ) +":"+ str( self.vectorAt(i).asList() )
+        return s+"]"