RKkit 0.1.0__py3-none-any.whl

RKkit/README.md

@@ -0,0 +1,2 @@
+
+The kernel is here.

RKkit/RKExceptions.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+"""
+Exceptions for the package RKkit
+"""
+from sage.structure.sage_object import SageObject
+from builtins import Exception
+#
+class DimensionsAreIncompatible(SageObject,Exception):
+    r"""
+    Exception raised when the sizes of A , B  and C
+    in a Runge-Kutta are not equal. 
+    """
+    def __init__(self,A,B,C):
+        self.An = A.dimensions()[0]
+        self.Bn = len(B)
+        self.Cn = len(C)
+    def __str__(self):
+        ret = "Butcher Array: dimension of A and B (or C) are not equal: " \
+            +str(self.An)+" , "+str(self.Bn)
+        if self.Cn != 0: ret+= " , "+str(self.Cn)
+class RootsException(Exception):
+    r"""
+    Exception raised when the roots of a given polynomial
+    could not be *all* computed (with their multiplicity).
+    (We generally compute in QQbar, and we can meet Evariste Gallois). 
+    """
+    def __init__(self,ncomp,pol):
+        self.ncomp = ncomp
+        self.degree = pol.degree
+        self.pol = pol
+    def __str__(self):
+        return "for " + str(self.pol) + " (degree= " + \
+            str(self.degree) + " ), only " \
+            +str(self.ncomp)+ " where computed."
+class MatrixIsSingular(Exception):
+    """
+    Exception raised when a matrix is singular.
+    """
+    def __init__(self,t):
+        self.t = t
+    def __str__(self):
+        return "for the method "+self.t+ " is a singular matrix"
+class GraphicProblem(Exception):
+    """
+    Exception raised when an error happens in a graphic.
+    """
+    def __init__(self,t):
+        self.t = t
+    def __str__(self):
+        return "Graphic problem: "+self.t
+class MustBeExact(Exception):
+    """
+    Raised if we try to compute in a non exact set (RealField, for example).
+    """
+    def __init__(self,t):
+        self.t=t
+    def __str__(self):
+        return self.t
+class NotA(Exception):
+    """
+    Raised if an object is not a matrix, vector, etc...
+    """
+    def __init__(self,t):
+        self.t=t
+    def __str__(self):
+        return self.t
+class CollocPointNotGood(Exception):
+    """
+    Raised if a collocation point is not in [0,1] 
+    """
+    def __init__(self,t):
+        self.t=t
+    def __str__(self):
+        return self.t

RKkit/RKPolutilities.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+"""
+Implement somme non implemented computations (in Sage) for polynomials.
+"""
+from sage.arith.power  import generic_power
+from sage.rings.qqbar import QQbar
+from sage.rings.imaginary_unit import I
+
+#
+def conj(P):
+    """
+    Conjugate of a polynomial P.
+    """
+    Pc = P.coefficients()
+    x = P.parent().gen()
+    return sum([Pc[p] * generic_power(x,p) for p in range(0,len(Pc))\
+                if Pc[p].imag() == 0]) - \
+                   sum([Pc[p] * generic_power(x,p) for p in range(0,len(Pc)) \
+                        if Pc[p].imag() != 0])
+def impart(P):
+    """
+    Imaginary part of a polynomial P.
+
+    (ie: compute sum Im P_i x^i only  for P_i imaginary).
+
+    """
+    Pc = P.coefficients()
+    x = P.parent().gen() 
+    Im = QQbar(I)
+    return sum([-Im * Pc[p]*generic_power(x,p) \
+                for p in range(0,len(Pc))  if Pc[p].imag() != 0])
+def realpart(P):
+    """
+    Real part of a polynomial P.
+
+    (ie: compute sum P_i x^i  only for P_i real).
+
+    """
+    x = P.parent().gen()
+    Pc = P.coefficients()
+    return sum([Pc[p] * generic_power(x,p) for p in range(0,len(Pc)) \
+                if Pc[p].imag() == 0])
+def roots_checked(pol,R):
+    """
+    Check that, computing in the ring R, we can compute n roots (with their
+    multiplicity) for a  polynomial pol of degree n.
+    """
+    q = pol.change_ring(R)
+    rac = q.roots()
+    n = sum([s[1] for s in rac])
+    return rac,pol.degree()== n, n
+

RKkit/RKRungeKutta.py

@@ -0,0 +1,30 @@
+from sage.structure.sage_object import SageObject
+from sage.structure.element import Matrix,Vector
+from .RKExceptions import *
+class RungeKutta(SageObject):
+    """
+    Base class for all Runge-Kutta methods.
+
+    """
+    def __init__(self,A,B,Title,C=[]):
+        if not A.parent().is_exact():
+            raise MustBeExact("RungeKutta: parent of A is not exact")
+        if not  B.parent().is_exact():
+            raise MustBeExact("RungeKutta: parent of B is not exact")
+        if not isinstance(A,Matrix):
+            raise NotA("RungeKutta: A is not a matrix")
+        if not isinstance(B,Vector):
+            raise NotA("RungeKutta: B is not a vector")
+        if  A.dimensions()[0] != A.dimensions()[1]\
+            or A.dimensions()[0] != len(B):
+            raise  DimensionsAreIncompatible(A,B,C)
+        if C != [] and len(C) != A.dimensions()[0]:
+            raise DimensionsAreIncompatible(A,B,C)
+            
+        
+        self.A = A
+        self.B = B
+        self.Title = Title
+        self.C = C
+    def __str__(self):
+        return self.Title+"\n"+str(self.A)+"\n"+str(self.B)

RKkit/RKTrees.py

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+#*
+from sage.structure.sage_object import SageObject
+from sage.combinat.rooted_tree import RootedTree as RT
+from sage.combinat.rooted_tree import RootedTrees_size as RTS
+from sage.categories.sets_cat import cartesian_product
+from sage.misc.misc_c import prod
+#
+class  RKTrees(SageObject):
+    r"""
+    The rooted trees machinery.    
+    EXAMPLES:
+
+    sage: R= RKTrees(n)
+
+    n is the maximum depth of the rooted trees you will use (the
+    built dictionary will be enlarged if necessary (lazzy evaluation)).
+
+    Bibliography: HW are the books of Hairer, Wanner and co-workers.
+    """
+    def __init__(self):
+        self.n = 1
+        self.dtrees = {}
+        self.expand(1)
+    def expand(self,l):
+        r"""
+        Extend the list of rooted trees up to depth l
+        """
+        for i in range(1,l+1):
+            if not i in self.dtrees:
+                self.dtrees[i] = RTS(i).list()
+        self.n=l
+    def gamma(self,t):
+        r"""
+        The gamma coefficient (see HW referenced books).
+        """
+        tn = t.node_number()
+        if tn == 1:
+            return 1
+        else:
+            return tn*prod([self.gamma(s) for s in t])
+    def _LabelledTree_to_formula(self,rtc,root_label,faclist):
+        if rtc.node_number() == 1:
+            faclist.append((root_label,rtc.label()))
+        else:
+            for t in rtc:
+                faclist.append((root_label,t.label()))
+                if t.node_number() > 1:
+                    self._LabelledTree_to_formula(t,t.label(),faclist)
+    def tree_to_order_formula(self,rt):
+        rtc = rt.canonical_labelling()
+        faclist = []
+        self._LabelledTree_to_formula(rtc,rtc.label(),faclist)
+        return faclist
+    def eval_sum_prod(self,A,B,formula,v):
+        return  B[v[0]] * prod( [A[v[i[0]-1],v[i[1]-1]] for i in formula] )
+    def tree_order_form(self,A,B,rt):
+        n = len(B)
+        s = set(range(0,n))
+        S = cartesian_product([s for i in range(0,rt.node_number())])
+        #
+        f = self.tree_to_order_formula(rt)
+        #
+        s =  sum([self.eval_sum_prod(A,B,f,v) for v in S])
+        return s*self.gamma(rt) 
+    def check_tree_order(self,A,B,rt):
+        return self.tree_order_form(A,B,rt) == 1
+    def check_order(self,A,B,order):
+        """
+        Prove that the rooted trees of order 'order' fullfill 
+        the requirements.
+
+        To check if a Runge-Kutta formula as order 'n', one must call 
+        check_order(A,B,i) for i in range(1,n+1).
+        """
+        if order == 1:
+            s = sum(B)
+            s.exactify()#should make sometime more readable results, may be.
+            return s == 1
+        else:
+            for i in range(len(self.dtrees)+1,order+1):
+                self.expand(i)
+            for t in self.dtrees[order]:
+                tc = t.canonical_labelling()
+                ok = self.check_tree_order(A,B,tc)
+                if not ok:
+                    return False
+            return True
+ 
+    def symetry_coefficient(self,rt):
+        rt1 = RT(rt)
+        if rt1 ==  RT([]):
+            return 1
+        else:
+            l = [t for t in rt1]
+            l.sort()
+            ft = 1
+            f = 1
+            for i in range(0,len(l)-1):
+                if l[i] == l[i+1]:
+                    f+= 1
+                else:
+                    ft*= factorial(f)
+                    f=1
+            if f != 1: ft*= factorial(f)
+            return prod([self.symetry_coefficient(s) for s in l])*ft
+    def compute_gamma(self):
+        r"""
+        This returns the '\gamma' coefficients (see HW).
+        """
+        self.gamma={}
+        for i in range(1,self.n+1):
+            for s in self.dtrees[i]:
+                self.gamma[s] = self.symetry_coefficient(s)

RKkit/RKcolloc.py

@@ -0,0 +1,71 @@
+from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
+from sage.matrix.constructor import Matrix,matrix
+from sage.modules.free_module_element import free_module_element,vector
+from sage.rings.qqbar import QQbar, AA
+from sage.functions.orthogonal_polys import legendre_P
+from .RKRungeKutta import RungeKutta
+from .RKExceptions import *
+def colloc(c,P,title):
+    """
+    Given a list C of collocation points in [0,1], and an univariate polynomial
+    ring P (over an exact field -actually over AA-),  build the A and B part
+    of the Butcher array of an associated  Runge-Kutta method and return a
+    Runge-Kutta method class.
+
+    The "title" parameter is the name given to the generated Runge-Kurtta
+    method.
+
+    AUTHOR::
+    
+    Thierry Dumont (2016, 2020).
+
+    EXAMPLES::
+
+    sage: R = PolynomialRing(AA,"x")
+    sage: n = 4
+    sage: x = P.gen()
+    sage: c = [(s[0]+1)/2 for s in R(legendre_P(n,x)).roots()]
+    sage: A,B = colloc(c,R,"Gauss 4")
+    """
+    
+    Pb= P.base()
+    x = P.gen()
+    n = len(c)
+    #
+    for s in c:
+        if s <0 or s >1:
+            raise CollocPointNotGood(
+                "colloc: collocation point ",s," is out of [0,1]")
+    pols=[]
+    for  i in range(0,n):
+        ploc=P(1)
+        for p in range(0,n):
+            if i!=p:
+                ploc *= P((x-c[p])/(Pb(c[i])-Pb(c[p])))
+        pols.append(ploc)
+
+    prims = [p.integral(x) for p in pols]
+    prims0 = [p(x = 0) for p in prims]
+    A = matrix(Pb,[ [prims[j](x = c[i]) - prims0[j] for j in range(0,n)] \
+                  for i in range(0,n)])
+    
+    B = [prims[j](x = 1) - prims0[j] for j in range(0,n)]
+    # exactify to improve lisibility, if possible!
+    if Pb is AA or Pb is QQbar:
+        for i in range(0,n):
+            for j in range(0,n):
+                A[i,j].exactify()
+            B[i].exactify()
+    B=vector(B)
+
+    def constructor(self):
+        # this will be the contructor of the class returned below.
+        self.Title=title
+        self.A = A
+        self.B = vector(B)
+        RungeKutta.__init__(self,A,B,self.Title)
+        
+    return type("Colloc"+str(len(c)),(RungeKutta,),{
+        "__init__": constructor,
+        })
+