Minor source corrections for compatibility

diff --git a/src/daComposant/daAlgorithms/NonLinearLeastSquares.py b/src/daComposant/daAlgorithms/NonLinearLeastSquares.py
index 5d2a3a7b081c8ce1de48949ed0b0d09ae8f42f2b..757cda1e1a4eb956270995c50e10a2c3d3c1bad5 100644 (file)
--- a/src/daComposant/daAlgorithms/NonLinearLeastSquares.py
+++ b/src/daComposant/daAlgorithms/NonLinearLeastSquares.py
@@ -102,7 +102,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
             Bounds = None
         #
         # Correction pour pallier a un bug de TNC sur le retour du Minimum
-        if self._parameters.has_key("Minimizer") is "TNC":
+        if self._parameters.has_key("Minimizer") == "TNC":
             self.setParameterValue("StoreInternalVariables",True)
         #
         # Opérateur d'observation

diff --git a/src/daComposant/daAlgorithms/QuantileRegression.py b/src/daComposant/daAlgorithms/QuantileRegression.py
index 620072189501f83aa47dc3d583fb77e10d37f833..eebc24e1d8f0d2fb2d368d6075419172d34bb79b 100644 (file)
--- a/src/daComposant/daAlgorithms/QuantileRegression.py
+++ b/src/daComposant/daAlgorithms/QuantileRegression.py
@@ -80,6 +80,12 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
         # ----------------------
         self.setParameters(Parameters)
         #
+        if self._parameters.has_key("Bounds") and (type(self._parameters["Bounds"]) is type([]) or type(self._parameters["Bounds"]) is type(())) and (len(self._parameters["Bounds"]) > 0):
+            Bounds = self._parameters["Bounds"]
+            logging.debug("%s Prise en compte des bornes effectuee"%(self._name,))
+        else:
+            Bounds = None
+        #
         # Opérateur d'observation
         # -----------------------
         Hm = HO["Direct"].appliedTo
@@ -136,6 +142,7 @@ class ElementaryAlgorithm(BasicObjects.Algorithm):
                 func        = CostFunction,
                 x0          = Xini,
                 fprime      = GradientOfCostFunction,
+                bounds      = Bounds,
                 quantile    = self._parameters["Quantile"],
                 maxfun      = self._parameters["MaximumNumberOfSteps"],
                 toler       = self._parameters["CostDecrementTolerance"],

diff --git a/src/daComposant/daCore/Persistence.py b/src/daComposant/daCore/Persistence.py
index 403214db292a290bbe20bd76681a89b4a5131c4b..283e0a6537937d45120d0a4f2d8949ab9b927436 100644 (file)
--- a/src/daComposant/daCore/Persistence.py
+++ b/src/daComposant/daCore/Persistence.py
@@ -657,7 +657,7 @@ class OneVector(Persistence):
     hypothèse par pas. Pour éviter les confusions, ne pas utiliser la classe
     "OneVector" pour des données hétérogènes, mais bien "OneList".
     """
-    def __init__(self, name="", unit="", basetype = list):
+    def __init__(self, name="", unit="", basetype = numpy.ravel):
         Persistence.__init__(self, name, unit, basetype)
 
 class OneMatrix(Persistence):
@@ -684,7 +684,7 @@ class OneNoType(Persistence):
     Classe définissant le stockage d'un objet sans modification (cast) de type.
     Attention, selon le véritable type de l'objet stocké à chaque pas, les
     opérations arithmétiques à base de numpy peuvent être invalides ou donner
-    des résultats inatendus. Cette classe n'est donc à utiliser qu'à bon escient
+    des résultats inattendus. Cette classe n'est donc à utiliser qu'à bon escient
     volontairement, et pas du tout par défaut.
     """
     def __init__(self, name="", unit="", basetype = NoType):

diff --git a/src/daComposant/daNumerics/mmqr.py b/src/daComposant/daNumerics/mmqr.py
index 8ba175c406b7dc94f5a0646d0d9cd6ab8f09f0ad..eeda601d55ad327509cf1ee4f8fd99ecd00c4578 100644 (file)
--- a/src/daComposant/daNumerics/mmqr.py
+++ b/src/daComposant/daNumerics/mmqr.py
@@ -28,13 +28,15 @@ __doc__ = """
 __author__ = "Jean-Philippe ARGAUD"
 
 import sys, math
-from numpy import sum, array, matrix, dot, linalg, asarray, asmatrix, ravel
+from numpy import array, matrix, asarray, asmatrix
+from numpy import sum, dot, linalg, ravel, max, min, hstack, argmin, argmax
 
 # ==============================================================================
 def mmqr(
         func     = None,
         x0       = None,
         fprime   = None,
+        bounds   = None,
         quantile = 0.5,
         maxfun   = 15000,
         toler    = 1.e-06,
@@ -58,7 +60,7 @@ def mmqr(
     #
     # Calculs d'initialisation
     # ------------------------
-    residus  = asmatrix( mesures - func( variables ) ).A1
+    residus  = ravel( mesures - func( variables ) )
     poids    = asarray( 1./(epsilon+abs(residus)) )
     veps     = 1. - 2. * quantile - residus * poids
     lastsurrogate = -sum(residus*veps) - (1.-2.*quantile)*sum(residus)
@@ -72,18 +74,22 @@ def mmqr(
         Derivees  = array(fprime(variables))
         Derivees  = Derivees.reshape(n,p) # Necessaire pour remettre en place la matrice si elle passe par des tuyaux YACS
         DeriveesT = array(matrix(Derivees).T)
-        M         = - dot( DeriveesT , (array(matrix(p*[poids,]).T)*Derivees) )
+        M         =   dot( DeriveesT , (array(matrix(p*[poids,]).T)*Derivees) )
         SM        =   dot( DeriveesT , veps ).T
-        step      = linalg.lstsq( M, SM )[0]
+        step      = - linalg.lstsq( M, SM )[0]
         #
         variables = variables + step
-        residus   = asmatrix( mesures - func(variables) ).A1
+        if bounds is not None:
+            while( (variables < ravel(asmatrix(bounds)[:,0])).any() or (variables > ravel(asmatrix(bounds)[:,1])).any() ):
+                step      = step/2.
+                variables = variables - step
+        residus   = ravel( mesures - func(variables) )
         surrogate = sum(residus**2 * poids) + (4.*quantile-2.) * sum(residus)
         #
         while ( (surrogate > lastsurrogate) and ( max(list(abs(step))) > 1.e-16 ) ) :
             step      = step/2.
             variables = variables - step
-            residus   = ( mesures-func(variables) ).A1
+            residus   = ravel( mesures-func(variables) )
             surrogate = sum(residus**2 * poids) + (4.*quantile-2.) * sum(residus)
         #
         increment     = lastsurrogate-surrogate