Index: pobysoPythonSage/src/sageSLZ/sageSLZ.sage
===================================================================
--- pobysoPythonSage/src/sageSLZ/sageSLZ.sage	(revision 71)
+++ pobysoPythonSage/src/sageSLZ/sageSLZ.sage	(revision 72)
@@ -1,4 +1,3 @@
-
 def slz_compute_polynomial_and_interval(functionSo, degreeSo, lowerBoundSa, 
                                         upperBoundSa, approxPrecSa, 
                                         sollyaPrecSa=None):
@@ -58,6 +57,53 @@
     return((polySo, currentRangeSo, intervalCenterSo, maxErrorSo))
     # End slz_compute_polynomial_and_interval
 
+def slz_compute_scaled_function(functionSa, \
+                                      variableNameSa, \
+                                      lowerBoundSa, \
+                                      upperBoundSa, \
+                                      floatingPointPrecSa):
+    """
+    From a function, compute the scaled function whose domain
+    is included in [1, 2) and whose image is also included in [1,2).
+    Return a tuple: 
+    [0]: the scaled function
+    [1]: the scaled domain lower bound
+    [2]: the scaled domain upper bound
+    [3]: the scaled image lower bound
+    [4]: the scaled image upper bound
+    """
+    x = var(variableNameSa)
+    # Scalling the domain -> [1,2[.
+    boundsIntervalRifSa = RealIntervalField(floatingPointPrecSa)
+    domainBoundsIntervalSa = boundsIntervalRifSa(lowerBoundSa, upperBoundSa)
+    (domainScalingExpressionSa, invDomainScalingExpressionSa) = \
+        slz_interval_scaling_expression(domainBoundsIntervalSa, variableNameSa)
+    print "domainScalingExpression for argument :", domainScalingExpressionSa
+    print "f: ", f
+    ff = f.subs({x : domainScalingExpressionSa})
+    #ff = f.subs_expr(x==domainScalingExpressionSa)
+    scaledLowerBoundSa = invDomainScalingExpressionSa(lowerBoundSa).n()
+    scaledUpperBoundSa = invDomainScalingExpressionSa(upperBoundSa).n()
+    print 'ff:', ff, "- Domain:", scaledLowerBoundSa, scaledUpperBoundSa
+    #
+    # Scalling the image -> [1,2[.
+    flbSa = f(lowerBoundSa).n()
+    fubSa = f(upperBoundSa).n()
+    if flbSa <= fubSa: # Increasing
+        imageBinadeBottomSa = floor(flbSa.log2())
+    else: # Decreasing
+        imageBinadeBottomSa = floor(fubSa.log2())
+    print 'ff:', ff, '- Image:', flbSa, fubSa, imageBinadeBottomSa
+    imageBoundsIntervalSa = boundsIntervalRifSa(flbSa, fubSa)
+    (imageScalingExpressionSa, invImageScalingExpressionSa) = \
+        slz_interval_scaling_expression(imageBoundsIntervalSa, variableNameSa)
+    iis = invImageScalingExpressionSa.function(x)
+    fff = iis.subs({x:ff})
+    print "fff:", fff,
+    print " - Image:", fff(scaledLowerBoundSa), fff(scaledUpperBoundSa)
+    return([fff, scaledLowerBoundSa, scaledUpperBoundSa, \
+            fff(scaledLowerBoundSa), fff(scaledUpperBoundSa)])
+
 def slz_get_intervals_and_polynomials(functionSa, variableNameSa, degreeSa, 
                                       lowerBoundSa, 
                                       upperBoundSa, floatingPointPrecSa, 
@@ -73,17 +119,12 @@
     - the floating-point precision we work on;
     - the internal Sollya precision;
     - the requested approximation error
-    compute a list of tuples made of:
-    - a polynomial approximating the function (a Sollya object);
-    - the range for which the polynomial approximates the function 
-      (a Sollya object);
-    - the center of the interval (a Sollya object);
-    - the actual approximation error (a Sage object). 
     The initial interval is, possibly, splitted into smaller intervals.
     It return a list of tuples, each made of:
-    - a polynomial;
+    - a first polynomial (without the changed variable f(x) = p(x-x0));
+    - a second polynomila (with a changed variable f(x) = q(x))
     - the approximation interval;
-    - the center, x0,  of the interval (the polynomial is defined as p(x-x0));
+    - the center, x0, of the interval;
     - the corresponding approximation error.
     """
     x = var(variableNameSa)
@@ -196,6 +237,19 @@
 
    
 def slz_polynomial_and_interval_to_sage(polyRangeCenterErrorSo):
+    """
+    Compute the Sage version of the Taylor polynomial and it's
+    companion data (interval, center...)
+    The input parameter is a five elements tuple:
+    - [0]: the polyomial (without variable change);
+    - [1]: the polyomial (with variable change done in Sollya);
+    - [2]: the interval (as Sollya range);
+    - [3]: the interval center;
+    - [4]: the approximation error. 
+    
+    The function return a 5 elements tuple: formed with all the 
+    input elements converted into their Sollya counterpart.
+    """
     polynomialSa = pobyso_get_poly_so_sa(polyRangeCenterErrorSo[0])
     polynomialChangedVarSa = pobyso_get_poly_so_sa(polyRangeCenterErrorSo[1])
     intervalSa = \
