Ticket #11634: trac_11634_pickling_for_PPL.patch

File trac_11634_pickling_for_PPL.patch, 14.3 KB (added by vbraun, 9 years ago)

Initial patch

  • sage/geometry/polyhedron/base.py

    # HG changeset patch
    # User Volker Braun <vbraun@stp.dias.ie>
    # Date 1314754708 14400
    # Node ID e1901734e40c50a2c74659614500cbb4a089f5fa
    # Parent  79395f6835a58d5f1e46bb194742ef28dc1a2966
    Trac #11634: Pickling for PPL Polyhedra
    
    diff --git a/sage/geometry/polyhedron/base.py b/sage/geometry/polyhedron/base.py
    a b  
    9898    TESTS::
    9999
    100100        sage: p = Polyhedron()
    101         sage: TestSuite(p).run(skip='_test_pickling')
     101        sage: TestSuite(p).run()
    102102    """
    103103
    104104    def __init__(self, ambient_dim, Vrep, Hrep, **kwds):
  • sage/libs/ppl.pyx

    diff --git a/sage/libs/ppl.pyx b/sage/libs/ppl.pyx
    a b  
    24322432        return result
    24332433
    24342434
     2435
    24352436####################################################
    24362437### C_Polyhedron ###################################
    24372438####################################################
     
    25342535            sage: C_Polyhedron(3, 'empty')   # indirect doctest
    25352536            The empty polyhedron in QQ^3
    25362537        """
    2537         if PY_TYPE_CHECK(arg, C_Polyhedron):
     2538        if isinstance(arg, C_Polyhedron):
    25382539            ph = <C_Polyhedron>arg
    25392540            self.thisptr = new PPL_C_Polyhedron(<PPL_C_Polyhedron&>ph.thisptr[0])
    25402541            return
    2541         if PY_TYPE_CHECK(arg, Generator):
     2542        if isinstance(arg, Generator):
    25422543            arg = Generator_System(arg)
    2543         if PY_TYPE_CHECK(arg, Constraint):
     2544        if isinstance(arg, Constraint):
    25442545            arg = Constraint_System(arg)
    2545         if PY_TYPE_CHECK(arg, Generator_System):
     2546        if isinstance(arg, Generator_System):
    25462547            gs = <Generator_System>arg
    25472548            self.thisptr = new PPL_C_Polyhedron(gs.thisptr[0])
    25482549            return
    2549         if PY_TYPE_CHECK(arg, Constraint_System):
     2550        if isinstance(arg, Constraint_System):
    25502551            cs = <Constraint_System>arg
    25512552            self.thisptr = new PPL_C_Polyhedron(cs.thisptr[0])
    25522553            return
     
    25882589        """
    25892590        del self.thisptr
    25902591
    2591        
     2592   
     2593    def __reduce__(self):
     2594        """
     2595        Pickle object
     2596
     2597        TESTS::
     2598
     2599            sage: from sage.libs.ppl import C_Polyhedron, Variable
     2600            sage: P = C_Polyhedron(3, 'empty')
     2601            sage: loads(dumps(P))
     2602            The empty polyhedron in QQ^3
     2603
     2604            sage: Q = C_Polyhedron(5, 'universe')
     2605            sage: loads(dumps(Q))
     2606            The space-filling polyhedron in QQ^5
     2607
     2608            sage: x = Variable(0)
     2609            sage: y = Variable(1)
     2610            sage: H = C_Polyhedron( 5*x-2*y >=  x+y-1 )
     2611            sage: loads(dumps(H))
     2612            A 2-dimensional polyhedron in QQ^2 defined as the convex hull of 1 point, 1 ray, 1 line
     2613        """
     2614        if self.is_empty():
     2615            return (C_Polyhedron, (self.space_dimension(), 'empty'))
     2616        elif self.is_universe():
     2617            return (C_Polyhedron, (self.space_dimension(), 'universe'))
     2618        else:
     2619            return (C_Polyhedron, (self.generators(),))
    25922620
    25932621
    25942622####################################################
     
    26832711            sage: NNC_Polyhedron(3, 'empty')   # indirect doctest
    26842712            The empty polyhedron in QQ^3
    26852713        """
    2686         if PY_TYPE_CHECK(arg, NNC_Polyhedron):
     2714        if isinstance(arg, NNC_Polyhedron):
    26872715            p_nnc = <NNC_Polyhedron>arg
    26882716            self.thisptr = new PPL_NNC_Polyhedron(<PPL_NNC_Polyhedron&>p_nnc.thisptr[0])
    26892717            return
    2690         if PY_TYPE_CHECK(arg, C_Polyhedron):
     2718        if isinstance(arg, C_Polyhedron):
    26912719            p_c = <C_Polyhedron>arg
    26922720            self.thisptr = new PPL_NNC_Polyhedron(<PPL_C_Polyhedron&>p_c.thisptr[0])
    26932721            return
    2694         if PY_TYPE_CHECK(arg, Generator):
     2722        if isinstance(arg, Generator):
    26952723            arg = Generator_System(arg)
    2696         if PY_TYPE_CHECK(arg, Constraint):
     2724        if isinstance(arg, Constraint):
    26972725            arg = Constraint_System(arg)
    2698         if PY_TYPE_CHECK(arg, Generator_System):
     2726        if isinstance(arg, Generator_System):
    26992727            gs = <Generator_System>arg
    27002728            self.thisptr = new PPL_NNC_Polyhedron(gs.thisptr[0])
    27012729            return
    2702         if PY_TYPE_CHECK(arg, Constraint_System):
     2730        if isinstance(arg, Constraint_System):
    27032731            cs = <Constraint_System>arg
    27042732            self.thisptr = new PPL_NNC_Polyhedron(cs.thisptr[0])
    27052733            return
     
    27412769        """
    27422770        del self.thisptr
    27432771
     2772   
     2773    def __reduce__(self):
     2774        """
     2775        Pickle object
     2776
     2777        TESTS::
     2778
     2779            sage: from sage.libs.ppl import NNC_Polyhedron, Variable
     2780            sage: P = NNC_Polyhedron(3, 'empty')
     2781            sage: loads(dumps(P))
     2782            The empty polyhedron in QQ^3
     2783
     2784            sage: Q = NNC_Polyhedron(5, 'universe')
     2785            sage: loads(dumps(Q))
     2786            The space-filling polyhedron in QQ^5
     2787
     2788            sage: x = Variable(0)
     2789            sage: y = Variable(1)
     2790            sage: H = NNC_Polyhedron( 5*x-2*y >  x+y-1 )
     2791            sage: loads(dumps(H))
     2792            A 2-dimensional polyhedron in QQ^2 defined as the convex hull of 1 point,
     2793            1 closure_point, 1 ray, 1 line
     2794        """
     2795        if self.is_empty():
     2796            return (NNC_Polyhedron, (self.space_dimension(), 'empty'))
     2797        elif self.is_universe():
     2798            return (NNC_Polyhedron, (self.space_dimension(), 'universe'))
     2799        else:
     2800            return (NNC_Polyhedron, (self.generators(),))
    27442801
    27452802
    27462803####################################################
     
    29653022            sage: 15 * y
    29663023            15*x1
    29673024        """
    2968         if PY_TYPE_CHECK(self, Variable):
     3025        if isinstance(self, Variable):
    29693026            return Linear_Expression(self) * other
    29703027        else:
    29713028            return Linear_Expression(other) * self
     
    31333190        else:
    31343191            assert False, 'Cannot initialize with more than 2 arguments.'
    31353192
    3136         if PY_TYPE_CHECK(arg, Variable):
     3193        if isinstance(arg, Variable):
    31373194            v = <Variable>arg
    31383195            self.thisptr = new PPL_Linear_Expression(v.thisptr[0])
    31393196            return
    3140         if PY_TYPE_CHECK(arg, Linear_Expression):
     3197        if isinstance(arg, Linear_Expression):
    31413198            e = <Linear_Expression>arg
    31423199            self.thisptr = new PPL_Linear_Expression(e.thisptr[0])
    31433200            return
     
    34723529        """
    34733530        cdef Linear_Expression e
    34743531        cdef Integer c
    3475         if PY_TYPE_CHECK(self, Linear_Expression):
     3532        if isinstance(self, Linear_Expression):
    34763533            e = <Linear_Expression>self
    34773534            c = Integer(other)
    34783535        else:
     
    35393596        return _make_Constraint_from_richcmp(self, other, op)
    35403597
    35413598
     3599    def __reduce__(self):
     3600        """
     3601        Pickle object
     3602
     3603        EXAMPLES::
     3604
     3605            sage: from sage.libs.ppl import Linear_Expression
     3606            sage: le = loads(dumps(Linear_Expression([1,2,3],4)))
     3607            sage: le.coefficients() == (1,2,3)
     3608            True
     3609            sage: le.inhomogeneous_term() == 4
     3610            True
     3611        """
     3612        return (Linear_Expression, (self.coefficients(), self.inhomogeneous_term()))
     3613
     3614
    35423615####################################################
    35433616### Generator ######################################
    35443617####################################################
     
    42024275        return self.thisptr.OK()
    42034276
    42044277
     4278    def __reduce__(self):
     4279        """
     4280        Pickle object.
     4281
     4282        TESTS::
     4283
     4284            sage: from sage.libs.ppl import Generator, Variable, line, ray, point, closure_point
     4285            sage: x = Variable(0); y = Variable(1);
     4286            sage: loads(dumps(Generator.point(2*x+7*y, 3)))
     4287            point(2/3, 7/3)
     4288            sage: loads(dumps(Generator.closure_point(2*x+7*y, 3)))
     4289            closure_point(2/3, 7/3)
     4290            sage: loads(dumps(Generator.line(2*x+7*y)))
     4291            line(2, 7)
     4292            sage: loads(dumps(Generator.ray(2*x+7*y)))
     4293            ray(2, 7)
     4294        """
     4295        t = self.thisptr.type()
     4296        le = Linear_Expression(self.coefficients(), 0)
     4297        if t==LINE:
     4298            return (line, (le,))
     4299        elif t==RAY:
     4300            return (ray, (le,))
     4301        elif t==POINT:
     4302            return (point, (le, self.divisor()))
     4303        elif t==CLOSURE_POINT:
     4304            return (closure_point, (le, self.divisor()))
     4305        assert False
     4306
     4307
    42054308
    42064309####################################################
    42074310def line(expression):
     
    43324435        if arg is None:
    43334436            self.thisptr = new PPL_Generator_System()
    43344437            return
    4335         if PY_TYPE_CHECK(arg, Generator):
     4438        if isinstance(arg, Generator):
    43364439            g = <Generator>arg
    43374440            self.thisptr = new PPL_Generator_System(g.thisptr[0])
    43384441            return
    4339         if PY_TYPE_CHECK(arg, Generator_System):
     4442        if isinstance(arg, Generator_System):
    43404443            gs = <Generator_System>arg
    43414444            self.thisptr = new PPL_Generator_System(gs.thisptr[0])
    43424445            return
     4446        if isinstance(arg, (list,tuple)):
     4447            self.thisptr = new PPL_Generator_System()
     4448            for generator in arg:
     4449                self.insert(generator)
     4450            return
    43434451        raise ValueError, 'Cannot initialize with '+str(arg)+'.'
    43444452
    43454453
     
    45114619        return s
    45124620
    45134621
     4622    def __reduce__(self):
     4623        """
     4624        Pickle object.
     4625       
     4626        TESTS::
     4627
     4628            sage: from sage.libs.ppl import Generator_System, Variable, point, ray
     4629            sage: x = Variable(0)
     4630            sage: y = Variable(1)
     4631            sage: gs = Generator_System((point(3*x+2*y+1), ray(x)));  gs
     4632            Generator_System {point(3/1, 2/1), ray(1, 0)}
     4633            sage: loads(dumps(gs))
     4634            Generator_System {point(3/1, 2/1), ray(1, 0)}
     4635        """
     4636        return (Generator_System, (tuple(self), ))
     4637   
     4638   
     4639
    45144640####################################################
    45154641### Generator_System_iterator ######################
    45164642####################################################
     
    50795205        """
    50805206        return self.thisptr.OK()
    50815207
     5208   
     5209    def __reduce__(self):
     5210        """
     5211        Pickle object.
     5212
     5213        EXAMPLES::
     5214
     5215            sage: from sage.libs.ppl import Linear_Expression, Variable
     5216            sage: x = Variable(0)
     5217            sage: y = Variable(1)
     5218            sage: loads(dumps(3*x+2*y+1>=5))
     5219            3*x0+2*x1-4>=0
     5220            sage: loads(dumps(3*x+2*y+1>5))
     5221            3*x0+2*x1-4>0
     5222            sage: loads(dumps(3*x+2*y+1==5))
     5223            3*x0+2*x1-4==0
     5224        """
     5225        le = Linear_Expression(self.coefficients(), self.inhomogeneous_term())
     5226        if self.is_nonstrict_inequality():
     5227            return (inequality, (le, ))
     5228        elif self.is_strict_inequality():
     5229            return (strict_inequality, (le, ))
     5230        elif self.is_equality():
     5231            return (equation, (le, ))
     5232        else:
     5233            assert False
     5234
     5235
     5236
     5237####################################################
     5238def inequality(expression):
     5239    """
     5240    Constuct an inequality.
     5241   
     5242    INPUT:
     5243
     5244    - ``expression`` -- a :class:`Linear_Expression`.
     5245
     5246    OUTPUT:
     5247   
     5248    The inequality ``expression`` >= 0.
     5249
     5250    EXAMPLES::
     5251
     5252        sage: from sage.libs.ppl import Variable, inequality
     5253        sage: y = Variable(1)
     5254        sage: 2*y+1 >= 0
     5255        2*x1+1>=0
     5256        sage: inequality(2*y+1)
     5257        2*x1+1>=0
     5258    """
     5259    return expression >= 0
     5260
     5261
     5262####################################################
     5263def strict_inequality(expression):
     5264    """
     5265    Constuct a strict inequality.
     5266   
     5267    INPUT:
     5268
     5269    - ``expression`` -- a :class:`Linear_Expression`.
     5270
     5271    OUTPUT:
     5272   
     5273    The inequality ``expression`` > 0.
     5274
     5275    EXAMPLES::
     5276
     5277        sage: from sage.libs.ppl import Variable, strict_inequality
     5278        sage: y = Variable(1)
     5279        sage: 2*y+1 > 0
     5280        2*x1+1>0
     5281        sage: strict_inequality(2*y+1)
     5282        2*x1+1>0
     5283    """
     5284    return expression > 0
     5285
     5286
     5287####################################################
     5288def equation(expression):
     5289    """
     5290    Constuct an equation.
     5291   
     5292    INPUT:
     5293
     5294    - ``expression`` -- a :class:`Linear_Expression`.
     5295
     5296    OUTPUT:
     5297   
     5298    The equation ``expression`` == 0.
     5299
     5300    EXAMPLES::
     5301
     5302        sage: from sage.libs.ppl import Variable, equation
     5303        sage: y = Variable(1)
     5304        sage: 2*y+1 == 0
     5305        2*x1+1==0
     5306        sage: equation(2*y+1)
     5307        2*x1+1==0
     5308    """
     5309    return expression == 0
     5310
     5311
    50825312
    50835313####################################################
    50845314### Constraint_System  ##############################
     
    51345364        if arg is None:
    51355365            self.thisptr = new PPL_Constraint_System()
    51365366            return
    5137         if PY_TYPE_CHECK(arg, Constraint):
     5367        if isinstance(arg, Constraint):
    51385368            g = <Constraint>arg
    51395369            self.thisptr = new PPL_Constraint_System(g.thisptr[0])
    51405370            return
    5141         if PY_TYPE_CHECK(arg, Constraint_System):
     5371        if isinstance(arg, Constraint_System):
    51425372            gs = <Constraint_System>arg
    51435373            self.thisptr = new PPL_Constraint_System(gs.thisptr[0])
    51445374            return
     5375        if isinstance(arg, (list,tuple)):
     5376            self.thisptr = new PPL_Constraint_System()
     5377            for constraint in arg:
     5378                self.insert(constraint)
     5379            return
    51455380        raise ValueError, 'Cannot initialize with '+str(arg)+'.'
    51465381
    51475382
     
    53515586            sage: from sage.libs.ppl import Constraint_System, Variable
    53525587            sage: x = Variable(0)
    53535588            sage: y = Variable(1)
    5354             sage: cs = Constraint_System( 3*x+2*y+1 < 3)
    5355             sage: cs.insert( 0*x>x+1 )
     5589            sage: cs = Constraint_System([3*x+2*y+1 < 3, 0*x>x+1])
    53565590            sage: cs.__repr__()
    53575591            'Constraint_System {-3*x0-2*x1+2>0, -x0-1>0}'
    53585592        """
     
    53625596        return s
    53635597
    53645598
     5599    def __reduce__(self):
     5600        """
     5601        Pickle object.
     5602       
     5603        TESTS::
     5604
     5605            sage: from sage.libs.ppl import Constraint_System, Variable
     5606            sage: x = Variable(0)
     5607            sage: y = Variable(1)
     5608            sage: cs = Constraint_System([3*x+2*y+1 < 3, 0*x>x+1]);  cs
     5609            Constraint_System {-3*x0-2*x1+2>0, -x0-1>0}
     5610            sage: loads(dumps(cs))
     5611            Constraint_System {-3*x0-2*x1+2>0, -x0-1>0}
     5612        """
     5613        return (Constraint_System, (tuple(self), ))
     5614
     5615
    53655616####################################################
    53665617### Constraint_System_iterator #####################
    53675618####################################################