fuse-element 0.1.dev0__py3-none-any.whl

fuse/triples.py

@@ -0,0 +1,470 @@
+from fuse.cells import Point
+from fuse.spaces.element_sobolev_spaces import ElementSobolevSpace
+from fuse.dof import DeltaPairing, L2Pairing, MyTestFunction, PointKernel
+from fuse.traces import Trace
+from fuse.groups import perm_matrix_to_perm_array
+from FIAT.dual_set import DualSet
+from FIAT.finite_element import CiarletElement
+import matplotlib as mpl
+mpl.use('Agg')
+import matplotlib.pyplot as plt
+import inspect
+from finat.ufl import FuseElement
+import warnings
+import numpy as np
+import scipy
+
+
+class ElementTriple():
+    """
+    Class to represent the three core parts of the element
+
+    :param: cell: CellComplex
+    :param: spaces: Triple of spaces: (PolynomialSpace, SobolovSpace, InterpolationSpace)
+    :param: dof_gen: Generator Triple to generate the degrees of freedom.
+    """
+
+    def __init__(self, cell, spaces, dof_gen):
+        assert isinstance(cell, Point)
+        if isinstance(dof_gen, DOFGenerator):
+            dof_gen = [dof_gen]
+        for d in dof_gen:
+            assert isinstance(d, DOFGenerator)
+            d.add_cell(cell)
+
+        self.cell = cell
+        cell_spaces = []
+        for space in spaces:
+            # TODO: Fix this to a more sensible condition when all spaces
+            # implemented
+            if inspect.isclass(space) and issubclass(space, ElementSobolevSpace):
+                cell_spaces.append(space(cell))
+            else:
+                cell_spaces.append(space)
+        self.spaces = tuple(cell_spaces)
+        self.DOFGenerator = dof_gen
+
+    def generate(self):
+        res = []
+        id_counter = 0
+        for dof_gen in self.DOFGenerator:
+            generated = dof_gen.generate(self.cell, self.spaces[1], id_counter)
+            res.extend(generated)
+            id_counter += len(generated)
+        return res
+
+    def __iter__(self):
+        yield self.cell
+        yield self.spaces
+        yield self.DOFGenerator
+
+    def num_dofs(self):
+        return sum([dof_gen.num_dofs() for dof_gen in self.DOFGenerator])
+
+    def get_dof_info(self, dof):
+        if dof.trace_entity.dimension == 0:
+            center = self.cell.cell_attachment(dof.trace_entity.id)()
+            color = "b"
+        elif dof.trace_entity.dimension == 1:
+            color = "r"
+            center = self.cell.cell_attachment(dof.trace_entity.id)(0)
+        elif dof.trace_entity.dimension == 2:
+            color = "g"
+            center = self.cell.cell_attachment(dof.trace_entity.id)(0, 0)
+        else:
+            color = "b"
+            center = None
+
+        return center, color
+
+    def get_value_shape(self):
+        # TODO Shape should be specificed somewhere else probably
+        if self.spaces[0].set_shape:
+            return (self.cell.get_spatial_dimension(),)
+        else:
+            return ()
+
+    def to_ufl(self):
+        return FuseElement(self)
+
+    def to_fiat(self):
+        ref_el = self.cell.to_fiat()
+        dofs = self.generate()
+        degree = self.spaces[0].degree()
+        entity_ids = {}
+        entity_perms = {}
+        nodes = []
+        top = ref_el.get_topology()
+        min_ids = self.cell.get_starter_ids()
+        poly_set = self.spaces[0].to_ON_polynomial_set(ref_el)
+
+        for dim in sorted(top):
+            entity_ids[dim] = {i: [] for i in top[dim]}
+            entity_perms[dim] = {}
+
+        for i in range(len(dofs)):
+            entity = dofs[i].trace_entity
+            dim = entity.dim()
+            entity_ids[dim][entity.id - min_ids[dim]].append(i)
+            nodes.append(dofs[i].convert_to_fiat(ref_el, degree))
+        entity_perms, pure_perm = self.make_dof_perms(ref_el, entity_ids, nodes, poly_set)
+
+        form_degree = 1 if self.spaces[0].set_shape else 0
+        print("my", [n.pt_dict for n in nodes])
+        print(entity_perms)
+        # TODO: Change this when Dense case in Firedrake
+        if pure_perm:
+            dual = DualSet(nodes, ref_el, entity_ids, entity_perms)
+        else:
+            dual = DualSet(nodes, ref_el, entity_ids)
+        return CiarletElement(poly_set, dual, degree, form_degree)
+
+    def plot(self, filename="temp.png"):
+        # point evaluation nodes only
+        dofs = self.generate()
+        identity = MyTestFunction(lambda *x: x)
+
+        if self.cell.dimension == 0:
+            raise ValueError(" Dimension 0 cells cannot be plotted")
+
+        if self.cell.dimension < 3:
+            fig = plt.figure()
+            ax = plt.gca()
+            self.cell.plot(show=False, plain=True, ax=ax)
+            for dof in dofs:
+                center, color = self.get_dof_info(dof)
+                if isinstance(dof.pairing, DeltaPairing) and isinstance(dof.kernel, PointKernel):
+                    coord = dof.eval(identity, pullback=False)
+                elif isinstance(dof.pairing, L2Pairing):
+                    coord = center
+                if len(coord) == 1:
+                    coord = (coord[0], 0)
+                if isinstance(dof.target_space, Trace):
+                    dof.target_space.plot(ax, coord, dof.trace_entity, dof.g, color=color)
+                else:
+                    ax.scatter(*coord, color=color)
+                ax.text(*coord, dof.id)
+
+            fig.savefig(filename)
+        elif self.cell.dimension == 3:
+            fig = plt.figure()
+            ax = fig.add_subplot(projection='3d')
+            self.cell.plot3d(show=False, ax=ax)
+            for dof in dofs:
+                center, color = self.get_dof_info(dof)
+                if center is None:
+                    center = [0, 0, 0]
+                if isinstance(dof.pairing, DeltaPairing):
+                    coord = dof.eval(identity, pullback=False)
+                    if isinstance(dof.target_space, Trace):
+                        dof.target_space.plot(ax, coord, dof.trace_entity, dof.g, color=color)
+                    else:
+                        ax.scatter(*coord, color=color)
+                elif isinstance(dof.pairing, L2Pairing):
+                    dof.target_space.plot(ax, center, dof.trace_entity, dof.g, color=color, length=0.2)
+                ax.text(*coord, dof.id)
+
+            fig.savefig(filename)
+        else:
+            raise ValueError("Plotting not supported in this dimension")
+
+    def compute_dense_matrix(self, ref_el, entity_ids, nodes, poly_set):
+        dual = DualSet(nodes, ref_el, entity_ids)
+
+        old_coeffs = poly_set.get_coeffs()
+        dualmat = dual.to_riesz(poly_set)
+
+        shp = dualmat.shape
+        A = dualmat.reshape((shp[0], -1))
+        B = old_coeffs.reshape((shp[0], -1))
+        V = np.dot(A, np.transpose(B))
+
+        with warnings.catch_warnings():
+            warnings.filterwarnings("error")
+            try:
+                new_coeffs_flat = scipy.linalg.solve(V, B, transposed=True)
+            except (scipy.linalg.LinAlgWarning, scipy.linalg.LinAlgError):
+                raise np.linalg.LinAlgError("Singular Vandermonde matrix")
+        return A, new_coeffs_flat
+
+    def make_overall_dense_matrices(self, ref_el, entity_ids, nodes, poly_set):
+        min_ids = self.cell.get_starter_ids()
+        dim = self.cell.dim()
+        e = self.cell
+        e_id = e.id - min_ids[dim]
+        res_dict = {dim: {e_id: {}}}
+        degree = self.spaces[0].degree()
+        original_V, original_basis = self.compute_dense_matrix(ref_el, entity_ids, nodes, poly_set)
+        for g in self.cell.group.members():
+            val = g.numeric_rep()
+            if g.perm.is_Identity:
+                res_dict[dim][e_id][val] = np.eye(len(nodes))
+            else:
+                new_nodes = [d(g).convert_to_fiat(ref_el, degree) for d in self.generate()]
+                transformed_V, transformed_basis = self.compute_dense_matrix(ref_el, entity_ids, new_nodes, poly_set)
+                res_dict[dim][e_id][val] = np.matmul(transformed_basis, original_V.T)
+        return res_dict
+
+    def make_dof_perms(self, ref_el, entity_ids, nodes, poly_set):
+        dofs = self.generate()
+        min_ids = self.cell.get_starter_ids()
+        entity_associations = {dim: {e.id - min_ids[dim]: {} for e in self.cell.d_entities(dim)}
+                               for dim in range(self.cell.dim() + 1)}
+        cell_dim = self.cell.dim()
+        cell_dict = entity_associations[cell_dim][self.cell.id - min_ids[cell_dim]]
+        pure_perm = True
+
+        # construct mapping of entities to the dof generators and the dofs they generate
+        for d in dofs:
+            sub_dim = d.trace_entity.dim()
+            sub_dict = entity_associations[sub_dim][d.trace_entity.id - min_ids[sub_dim]]
+            dof_gen = str(d.generation[sub_dim])
+            if not len(d.generation[sub_dim].g2.members()) == 1:
+                pure_perm = False
+            if dof_gen in sub_dict.keys():
+                sub_dict[dof_gen] += [d]
+            else:
+                sub_dict[dof_gen] = [d]
+            if sub_dim != cell_dim:
+                dof_gen = str(d.generation[cell_dim])
+                if not len(d.generation[cell_dim].g2.members()) == 1:
+                    pure_perm = False
+
+                if dof_gen in cell_dict.keys():
+                    cell_dict[dof_gen] += [d]
+                else:
+                    cell_dict[dof_gen] = [d]
+
+        if pure_perm is False:
+            # TODO think about where this call goes
+            return self.make_overall_dense_matrices(ref_el, entity_ids, nodes, poly_set), pure_perm
+
+        dof_id_mat = np.eye(len(dofs))
+        oriented_mats_by_entity = {}
+        flat_by_entity = {}
+
+        # for each entity, look up generation on that entity and permute the
+        # dof mapping according to the generation
+        for dim in range(self.cell.dim()):
+            oriented_mats_by_entity[dim] = {}
+            flat_by_entity[dim] = {}
+            ents = self.cell.d_entities(dim)
+            for e in ents:
+                e_id = e.id - min_ids[dim]
+                members = e.group.members()
+                oriented_mats_by_entity[dim][e_id] = {}
+                flat_by_entity[dim][e_id] = {}
+                for g in members:
+                    val = g.numeric_rep()
+                    oriented_mats_by_entity[dim][e_id][val] = dof_id_mat.copy()
+                    flat_by_entity[dim][e_id][val] = []
+                    total_ent_dof_ids = []
+                    for dof_gen in entity_associations[dim][e_id].keys():
+                        ent_dofs = entity_associations[dim][e_id][dof_gen]
+                        ent_dofs_ids = np.array([ed.id for ed in ent_dofs], dtype=int)
+                        total_ent_dof_ids += [ed.id for ed in ent_dofs]
+                        dof_gen_class = ent_dofs[0].generation[dim]
+
+                        # if not len(dof_gen_class.g2.members()) == 1:
+                        #     print("NOT PERM")
+                        #     degree = ent_dofs[0].triple.spaces[0].degree()
+                        #     nodes = [d.convert_to_fiat(ref_el, degree) for d in ent_dofs]
+                        #     new_nodes = [d(g).convert_to_fiat(ref_el, degree) for d in ent_dofs]
+                        #     sub_ref_el = ref_el.construct_subelement(dim)
+                        #     print("sub ref el", sub_ref_el.fe_cell.get_topology())
+                        #     print("sub ref el", sub_ref_el.get_spatial_dimension())
+                        #     sub_poly_set = ent_dofs[0].triple.spaces[0].to_ON_polynomial_set(sub_ref_el)
+                        #     print(new_nodes)
+                        #     print([d(g) for d in ent_dofs])
+                        #     print(entity_ids)
+                        #     print(entity_ids[e.dimension][e_id])
+                        #     print(ent_dofs_ids)
+                        #     print(sub_poly_set)
+                        #     sub_entity_ids = dof_gen_class.make_entity_ids()
+                        #     print(sub_ref_el.get_topology())
+                        #     transformed_V, transformed_basis = self.compute_dense_matrix(sub_ref_el, sub_entity_ids, new_nodes, sub_poly_set)
+                        #     original_V, original_basis = self.compute_dense_matrix(sub_ref_el, sub_entity_ids, nodes, sub_poly_set)
+                        #     print(transformed_V)
+                        #     res_dict[dim][e_id][val] = np.matmul(transformed_basis, original_V.T)
+                        # TODO not sure about correctness of this
+                        if g.perm.is_Identity or (pure_perm and len(ent_dofs_ids) == 1):
+                            oriented_mats_by_entity[dim][e_id][val][np.ix_(ent_dofs_ids, ent_dofs_ids)] = np.eye(len(ent_dofs_ids))
+                        elif g in dof_gen_class.g1.members():
+                            sub_mat = g.matrix_form()
+                            oriented_mats_by_entity[dim][e_id][val][np.ix_(ent_dofs_ids, ent_dofs_ids)] = sub_mat.copy()
+                        else:
+                            pass
+                            # # sub component dense case
+                    flat_by_entity[dim][e_id][val] = perm_matrix_to_perm_array(oriented_mats_by_entity[dim][e_id][val][np.ix_(total_ent_dof_ids, total_ent_dof_ids)])
+
+        oriented_mats_overall = {}
+        dim = self.cell.dim()
+        e = self.cell
+        e_id = e.id - min_ids[dim]
+        flat_by_entity[dim] = {e_id: {}}
+        members = e.group.members()
+        for g in members:
+            val = g.numeric_rep()
+            oriented_mats_overall[val] = dof_id_mat.copy()
+            flat_by_entity[dim][e_id][val] = []
+            for dof_gen in entity_associations[dim][e_id].keys():
+                ent_dofs = entity_associations[dim][e_id][dof_gen]
+                ent_dofs_ids = np.array([ed.id for ed in ent_dofs], dtype=int)
+                dof_gen_class = ent_dofs[0].generation
+                for key in dof_gen_class.keys():
+                    if not key == dim:
+                        immersed_dim = key
+                        for sub_e, sub_g in e.permute_entities(g, immersed_dim):
+                            sub_e = e.get_node(sub_e)
+                            sub_e_id = sub_e.id - min_ids[sub_e.dim()]
+                            sub_ent_ids = []
+                            for (k, v) in entity_associations[immersed_dim][sub_e_id].items():
+                                sub_ent_ids += [e.id for e in v]
+                            sub_mat = oriented_mats_by_entity[immersed_dim][sub_e_id][sub_g.numeric_rep()][np.ix_(sub_ent_ids, sub_ent_ids)]
+                            g_sub_mat = g.matrix_form()
+                            expanded = np.kron(g_sub_mat, sub_mat)
+                            # potentially permute the dof ids instead
+                            oriented_mats_overall[val][np.ix_(ent_dofs_ids, ent_dofs_ids)] = expanded.copy()
+                    elif len(dof_gen_class.keys()) == 1:
+                        if g in dof_gen_class[dim].g1.members() or (pure_perm and len(dof_gen_class[dim].g1.members()) > 1):
+                            sub_mat = g.matrix_form()
+                            oriented_mats_overall[val][np.ix_(ent_dofs_ids, ent_dofs_ids)] = sub_mat.copy()
+
+        for val, mat in oriented_mats_overall.items():
+            cell_dofs = entity_ids[dim][0]
+            flat_by_entity[dim][e_id][val] = perm_matrix_to_perm_array(mat[np.ix_(cell_dofs, cell_dofs)])
+        return flat_by_entity, pure_perm
+
+    def _to_dict(self):
+        o_dict = {"cell": self.cell, "spaces": self.spaces, "dofs": self.DOFGenerator}
+        return o_dict
+
+    def dict_id(self):
+        return "Triple"
+
+    def _from_dict(o_dict):
+        return ElementTriple(o_dict["cell"], o_dict["spaces"], o_dict["dofs"])
+
+
+class DOFGenerator():
+
+    def __init__(self, generator_funcs, gen_group, trans_group):
+        # assert isinstance(G_1, Group)
+        # assert isinstance(G_2, Group)
+        self.x = generator_funcs
+        self.g1 = gen_group
+        self.g2 = trans_group
+        self.dof_numbers = None
+        self.ls = None
+
+    def __iter__(self):
+        yield self.x
+        yield self.g1
+        yield self.g2
+
+    def add_cell(self, cell):
+        self.g1 = self.g1.add_cell(cell)
+        self.g2 = self.g2.add_cell(cell)
+
+    def num_dofs(self):
+        if self.dof_numbers is None:
+            raise ValueError("DOFs not generated yet")
+        return self.dof_numbers
+
+    def generate(self, cell, space, id_counter):
+        if self.ls is None:
+            self.ls = []
+            for l_g in self.x:
+                i = 0
+                for g in self.g1.members():
+                    generated = l_g(g)
+                    if not isinstance(generated, list):
+                        generated = [generated]
+                    for dof in generated:
+                        dof.add_context(self, cell, space, g, id_counter, i)
+                        id_counter += 1
+                        i += 1
+                    self.ls.extend(generated)
+            self.dof_numbers = len(self.ls)
+            self.dof_ids = [dof.id for dof in self.ls]
+        return self.ls
+
+    def make_entity_ids(self):
+        dofs = self.ls
+        entity_ids = {}
+        min_ids = dofs[0].cell.get_starter_ids()
+
+        top = dofs[0].cell.get_topology()
+
+        for dim in sorted(top):
+            entity_ids[dim] = {i: [] for i in top[dim]}
+
+        for i in range(len(dofs)):
+            entity = dofs[i].trace_entity
+            dim = entity.dim()
+            entity_ids[dim][entity.id - min_ids[dim]].append(i)
+        return entity_ids
+
+    def __repr__(self):
+        repr_str = "DOFGen("
+        for x_elem in self.x:
+            repr_str += "g(" + str(x_elem) + ")"
+        repr_str += str(self.g1) + str(self.g2) + ")"
+        return repr_str
+
+    def _to_dict(self):
+        o_dict = {"x": self.x, "g1": self.g1, "g2": self.g2}
+        return o_dict
+
+    def dict_id(self):
+        return "DOFGen"
+
+    def _from_dict(obj_dict):
+        return DOFGenerator(obj_dict["x"], obj_dict["g1"], obj_dict["g2"])
+
+
+class ImmersedDOFs():
+
+    def __init__(self, target_cell, triple, trace, start_node=0):
+        self.target_cell = target_cell
+        self.triple = triple
+        self.C, self.V, self.E = triple
+        self.trace = trace(target_cell)
+        self.start_node = start_node
+
+    def __call__(self, g):
+        target_node, o = self.target_cell.permute_entities(g, self.C.dim())[self.start_node]
+        if self.C.dim() > 0 and o != o.group.identity:
+            raise ValueError("Not matching orientation - groups incorrect")
+        attachment = self.target_cell.cell_attachment(target_node)
+        new_dofs = []
+
+        def oriented_attachment(*x):
+            return attachment(*o(x))
+
+        for generated_dof in self.triple.generate():
+            new_dof = generated_dof.immerse(self.target_cell.get_node(target_node),
+                                            oriented_attachment,
+                                            self.trace, g, self.triple)
+            new_dofs.append(new_dof)
+        return new_dofs
+
+    def __repr__(self):
+        repr_str = ""
+        for dof_gen in self.E:
+            repr_str += "Im_" + str(self.trace) + "_" + str(self.target_cell) + "(" + str(dof_gen) + ")"
+        return repr_str
+
+    def _to_dict(self):
+        o_dict = {"target_cell": self.target_cell, "triple": self.triple, "trace": self.trace}
+        return o_dict
+
+    def dict_id(self):
+        return "ImmersedDOF"
+
+    def _from_dict(obj_dict):
+        return ImmersedDOFs(obj_dict["target_cell"], obj_dict["triple"], obj_dict["trace"])
+
+
+def immerse(target_cell, triple, target_space, node=0):
+    return ImmersedDOFs(target_cell, triple, target_space, node)

fuse/utils.py

@@ -0,0 +1,64 @@
+import numpy as np
+import sympy as sp
+
+
+def fold_reduce(func_list, *prev):
+    """
+    Right to left function comprehension
+
+    :param: func_list: list of functions
+    :param: prev: starting value(s)
+    """
+    for func in reversed(func_list):
+        prev = func(*prev)
+    return prev
+
+
+def sympy_to_numpy(array, symbols, values):
+    """
+    Convert a sympy array to a numpy array.
+
+    :param: array: sympy array
+    :param: symbols: array of symbols contained in the sympy exprs
+    :param: values: array of values to replace the symbols with.
+
+    Due to how sympy handles arrays, we need to squeeze if resulting array
+    is greater than 1 dimension to remove extra dimensions
+    """
+    substituted = array.subs({symbols[i]: values[i] for i in range(len(values))})
+    nparray = np.array(substituted).astype(np.float64)
+
+    if len(nparray.shape) > 1:
+        return nparray.squeeze()
+
+    if len(nparray.shape) == 0:
+        return nparray.item()
+
+    return nparray
+
+
+def tabulate_sympy(expr, pts):
+    # expr: sp matrix expression in x,y,z for components of R^d
+    # pts: n values in R^d
+    # returns: evaluation of expr at pts
+    res = np.array(pts)
+    i = 0
+    syms = ["x", "y", "z"]
+    for pt in pts:
+        if not hasattr(pt, "__iter__"):
+            pt = (pt,)
+        subbed = expr.evalf(subs={syms[i]: pt[i] for i in range(len(pt))})
+        subbed = np.array(subbed).astype(np.float64)
+        res[i] = subbed[0]
+        i += 1
+    final = res.squeeze()
+    return final
+
+
+def max_deg_sp_mat(sp_mat):
+    degs = []
+    for comp in sp_mat:
+        # only compute degree if component is a polynomial
+        if sp.sympify(comp).as_poly():
+            degs += [sp.sympify(comp).as_poly().degree()]
+    return max(degs)

fuse_element-0.1.dev0.dist-info/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.