Flint2 0.1.0.1 → 0.1.0.2

raw patch · 101 files changed

+12332/−5086 lines, 101 filesdep +containersdep ~QuickCheckdep ~groupsPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: containers

Dependency ranges changed: QuickCheck, groups

API changes (from Hackage documentation)

Files

• Flint2.cabal +43/−7
• LICENSE +233/−396
• README.md +13/−30
• csrc/arb.h +2/−0
• csrc/arb/radref.c +12/−0
• csrc/ca_ext/io.c +76/−0
• csrc/ca_mat/io.c +50/−0
• csrc/ca_poly/io.c +46/−0
• csrc/dirichlet.h +16/−0
• csrc/dirichlet/io.c +47/−0
• csrc/fmpz_mpoly_factor.h +18/−0
• csrc/fmpz_mpoly_factor/io.c +38/−0
• package.yaml +63/−8
• src/Data/Number/Flint.hs +25/−2
• src/Data/Number/Flint/Acb/Calc/FFI.hsc +31/−6
• src/Data/Number/Flint/Acb/FFI.hsc +19/−3
• src/Data/Number/Flint/Acb/Instances.hs +0/−1
• src/Data/Number/Flint/Acb/Mat/Instances.hs +0/−1
• src/Data/Number/Flint/Acb/Modular/FFI.hsc +0/−1
• src/Data/Number/Flint/Acb/Modular/Instances.hs +0/−1
• src/Data/Number/Flint/Acb/Poly/Instances.hs +0/−1
• src/Data/Number/Flint/Acb/Types.hs +0/−1
• src/Data/Number/Flint/Arb/Arf/FFI.hsc +2/−1
• src/Data/Number/Flint/Arb/Calc/FFI.hsc +18/−2
• src/Data/Number/Flint/Arb/FFI.hsc +12/−2
• src/Data/Number/Flint/Arb/Fmpz/Poly/FFI.hsc +11/−1
• src/Data/Number/Flint/Arb/Instances.hs +5/−2
• src/Data/Number/Flint/Arb/Mag/FFI.hsc +1/−0
• src/Data/Number/Flint/Arb/Mag/Instances.hs +67/−0
• src/Data/Number/Flint/Arb/Mat/Instances.hs +0/−1
• src/Data/Number/Flint/Arb/Poly/FFI.hsc +7/−0
• src/Data/Number/Flint/Arb/Poly/Instances.hs +0/−1
• src/Data/Number/Flint/Arb/RealField.hs +1/−2
• src/Data/Number/Flint/Arb/Types.hs +0/−1
• src/Data/Number/Flint/Arb/Types/FFI.hsc +9/−13
• src/Data/Number/Flint/Bernoulli/FFI.hsc +7/−0
• src/Data/Number/Flint/Calcium.hs +17/−0
• src/Data/Number/Flint/Calcium/Ca.hs +82/−0
• src/Data/Number/Flint/Calcium/Ca/Ext.hs +33/−0
• src/Data/Number/Flint/Calcium/Ca/Ext/FFI.hsc +262/−0
• src/Data/Number/Flint/Calcium/Ca/FFI.hsc +2106/−0
• src/Data/Number/Flint/Calcium/Ca/Field.hs +33/−0
• src/Data/Number/Flint/Calcium/Ca/Field/FFI.hsc +176/−0
• src/Data/Number/Flint/Calcium/Ca/Mat.hs +21/−0
• src/Data/Number/Flint/Calcium/Ca/Mat/FFI.hsc +933/−0
• src/Data/Number/Flint/Calcium/Ca/Poly.hs +11/−0
• src/Data/Number/Flint/Calcium/Ca/Poly/FFI.hsc +728/−0
• src/Data/Number/Flint/Calcium/Ca/Types.hs +11/−0
• src/Data/Number/Flint/Calcium/Ca/Types/FFI.hsc +65/−0
• src/Data/Number/Flint/Calcium/Ca/Vec.hs +22/−0
• src/Data/Number/Flint/Calcium/Ca/Vec/FFI.hsc +304/−0
• src/Data/Number/Flint/Calcium/FFI.hsc +280/−0
• src/Data/Number/Flint/Calcium/Fexpr.hs +114/−0
• src/Data/Number/Flint/Calcium/Fexpr/Builtin.hs +543/−0
• src/Data/Number/Flint/Calcium/Fexpr/FFI.hsc +863/−0
• src/Data/Number/Flint/Calcium/Fexpr/Instances.hs +117/−0
• src/Data/Number/Flint/Flint.hs +0/−1
• src/Data/Number/Flint/Flint/External.hs +0/−1
• src/Data/Number/Flint/Flint/Internal.hs +0/−1
• src/Data/Number/Flint/Fmpq/Instances.hs +13/−11
• src/Data/Number/Flint/Fmpq/Mat/Instances.hs +0/−1
• src/Data/Number/Flint/Fmpq/Poly/Instances.hs +20/−1
• src/Data/Number/Flint/Fmpz/FFI.hsc +4/−0
• src/Data/Number/Flint/Fmpz/Instances.hs +0/−1
• src/Data/Number/Flint/Fmpz/MPoly/FFI.hsc +6/−0
• src/Data/Number/Flint/Fmpz/MPoly/Factor/FFI.hsc +22/−0
• src/Data/Number/Flint/Fmpz/Mat.hs +4/−4
• src/Data/Number/Flint/Fmpz/Mat/Instances.hs +0/−1
• src/Data/Number/Flint/Fmpz/Mod/Poly/FFI.hsc +41/−10
• src/Data/Number/Flint/Fmpz/Poly/FFI.hsc +4519/−4485
• src/Data/Number/Flint/Fmpz/Poly/Factor/FFI.hsc +1/−0
• src/Data/Number/Flint/Fmpz/Poly/Instances.hs +18/−15
• src/Data/Number/Flint/Fmpz/Poly/Q/Instances.hs +0/−1
• src/Data/Number/Flint/Fq/Embed.hs +0/−1
• src/Data/Number/Flint/Fq/Mat.hs +4/−4
• src/Data/Number/Flint/Fq/NMod.hs +4/−4
• src/Data/Number/Flint/Fq/NMod/Embed.hs +4/−4
• src/Data/Number/Flint/Fq/NMod/Mat.hs +4/−4
• src/Data/Number/Flint/Fq/NMod/Types.hs +0/−1
• src/Data/Number/Flint/Fq/NMod/Types/FFI.hsc +0/−1
• src/Data/Number/Flint/Fq/NMod/Vec.hs +4/−4
• src/Data/Number/Flint/Fq/Poly.hs +4/−4
• src/Data/Number/Flint/Fq/Types.hs +0/−1
• src/Data/Number/Flint/Fq/Types/FFI.hsc +0/−1
• src/Data/Number/Flint/Fq/Vec.hs +4/−4
• src/Data/Number/Flint/Fq/Zech.hs +4/−4
• src/Data/Number/Flint/Fq/Zech/Embed.hs +4/−4
• src/Data/Number/Flint/Fq/Zech/Mat.hs +4/−4
• src/Data/Number/Flint/Fq/Zech/Poly.hs +4/−4
• src/Data/Number/Flint/Fq/Zech/Types.hs +4/−5
• src/Data/Number/Flint/Fq/Zech/Vec.hs +4/−4
• src/Data/Number/Flint/Groups/Dirichlet/FFI.hsc +14/−3
• src/Data/Number/Flint/Groups/Qfb/Instances.hs +0/−1
• src/Data/Number/Flint/NF/Fmpzi/Instances.hs +0/−1
• src/Data/Number/Flint/NF/QQbar/FFI.hsc +5/−1
• src/Data/Number/Flint/NF/QQbar/Instances.hs +0/−1
• src/Data/Number/Flint/NMod/Poly/Instances.hs +0/−1
• src/Data/Number/Flint/NMod/Types.hs +0/−1
• src/Data/Number/Flint/Padic/Poly/FFI.hsc +6/−1
• src/Data/Number/Flint/Qadic/FFI.hsc +14/−0
• src/Data/Number/Flint/Support/D/Mat/Instances.hs +0/−1

@@ -5,16 +5,22 @@ -- see: https://github.com/sol/hpack  name:           Flint2-version:        0.1.0.1+version:        0.1.0.2 synopsis:       Haskell bindings for the flint library for number theory-description:    Please see the README on GitHub at <https://github.com/monien/Flint2#readme>+description:    A Haskell Wrapper for Flint+                This library provides access to the functionality of the FLINT.+                So what is it?+                FLINT is a C library for doing number theory, freely available under the GNU LGPL at [https://flintlib.org](https://flintlib.org)+                At its core, FLINT provides arithmetic in standard rings such as the integers, rationals, algebraic, real, complex and p-adic numbers, finite fields, and number fields. It also provides polynomials (univariate and multivariate), power series, and matrices.+                At the research frontier+                FLINT has been used for many large scale research computations (e.g. A Trillion Triangles) and has been cited in hundreds of publications. FLINT's authors themselves have published more than 20 papers describing new algorithms first implemented within or on top of FLINT. category:       Math homepage:       https://github.com/monien/Flint2#readme bug-reports:    https://github.com/monien/Flint2/issues author:         Hartmut Monien maintainer:     hmonien@uni-bonn.de-copyright:      Copyright (c) 2022 Hartmut Monien-license:        BSD3+copyright:      Copyright (c) 2023 Hartmut Monien+license:        GPL-2 license-file:   LICENSE build-type:     Simple extra-source-files:@@ -134,6 +140,7 @@       Data.Number.Flint.Arb       Data.Number.Flint.Arb.Instances       Data.Number.Flint.Arb.Mag+      Data.Number.Flint.Arb.Mag.Instances       Data.Number.Flint.Arb.Arf       Data.Number.Flint.Arb.Poly       Data.Number.Flint.Arb.Poly.Instances@@ -160,6 +167,17 @@       Data.Number.Flint.Acb.DFT       Data.Number.Flint.Acb.ComplexField       Data.Number.Flint.Acb.Calc+      Data.Number.Flint.Calcium+      Data.Number.Flint.Calcium.Ca+      Data.Number.Flint.Calcium.Ca.Types+      Data.Number.Flint.Calcium.Ca.Poly+      Data.Number.Flint.Calcium.Ca.Vec+      Data.Number.Flint.Calcium.Ca.Mat+      Data.Number.Flint.Calcium.Ca.Field+      Data.Number.Flint.Calcium.Ca.Ext+      Data.Number.Flint.Calcium.Fexpr+      Data.Number.Flint.Calcium.Fexpr.Instances+      Data.Number.Flint.Calcium.Fexpr.Builtin       Data.Number.Flint.Bernoulli       Data.Number.Flint.Partitions       Data.Number.Flint.Hypgeom@@ -276,6 +294,15 @@       Data.Number.Flint.Acb.Dirichlet.FFI       Data.Number.Flint.Acb.DFT.FFI       Data.Number.Flint.Acb.Calc.FFI+      Data.Number.Flint.Calcium.FFI+      Data.Number.Flint.Calcium.Ca.FFI+      Data.Number.Flint.Calcium.Ca.Types.FFI+      Data.Number.Flint.Calcium.Ca.Poly.FFI+      Data.Number.Flint.Calcium.Ca.Vec.FFI+      Data.Number.Flint.Calcium.Ca.Mat.FFI+      Data.Number.Flint.Calcium.Ca.Field.FFI+      Data.Number.Flint.Calcium.Ca.Ext.FFI+      Data.Number.Flint.Calcium.Fexpr.FFI       Data.Number.Flint.Bernoulli.FFI       Data.Number.Flint.Partitions.FFI       Data.Number.Flint.Hypgeom.FFI@@ -317,6 +344,7 @@       arf.h       bool_mat.h       d_mat.h+      dirichlet.h       double_interval.h       fmpq.h       fmpq_mat.h@@ -326,6 +354,7 @@       fmpz_factor.h       fmpz_mat.h       fmpz_mod_poly_factor.h+      fmpz_mpoly_factor.h       fmpz_mpoly_q.h       fmpz_poly_mat.h       fmpz_vec.h@@ -356,6 +385,7 @@       csrc/fmpz_poly_mat/fprint.c       csrc/fmpz_poly_mat/get_str.c       csrc/fmpz_factor/get_str.c+      csrc/fmpz_mpoly_factor/io.c       csrc/fmpz_mpoly_q/fprint.c       csrc/fmpz_mpoly_q/get_str_pretty.c       csrc/fmpz_vec/get_str.c@@ -382,6 +412,7 @@       csrc/aprcl/fprint.c       csrc/aprcl/get_str.c       csrc/bool_mat/get_str.c+      csrc/dirichlet/io.c       csrc/qfb/get_str.c       csrc/qfb/fprint.c       csrc/qqbar/fprint.c@@ -410,6 +441,7 @@       csrc/d_mat/entry.c       csrc/d_mat/io.c       csrc/arb/midref.c+      csrc/arb/radref.c       csrc/arf/inlines.c       csrc/mag/get_str.c       csrc/arb/get_strd.c@@ -434,21 +466,25 @@       csrc/acb_modular/inlines.c       csrc/acb_modular/get_str.c       csrc/mpfr_mat/swap_entrywise.c+      csrc/ca_poly/io.c+      csrc/ca_mat/io.c+      csrc/ca_ext/io.c       csrc/psl2z/word_problem.c       csrc/perm/order.c       csrc/perm/print_pretty.c       csrc/perm/power.c       csrc/perm/mat.c   extra-libraries:-      flint, gmp+      flint   pkgconfig-depends:       flint >= 2.9, gmp   build-tools:       hsc2hs   build-depends:-      QuickCheck+      QuickCheck >=2.14.3 && <2.15     , base >=4.7 && <5-    , groups+    , containers >=0.6.5 && <0.7+    , groups >=0.5.3 && <0.6   default-language: Haskell2010  test-suite Flint2-test

@@ -1,397 +1,221 @@-                  GNU LESSER GENERAL PUBLIC LICENSE-                       Version 2.1, February 1999+                    GNU GENERAL PUBLIC LICENSE+                       Version 2, June 1991 - Copyright (C) 1991, 1999 Free Software Foundation, Inc.- 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA  Everyone is permitted to copy and distribute verbatim copies  of this license document, but changing it is not allowed. -[This is the first released version of the Lesser GPL.  It also counts- as the successor of the GNU Library Public License, version 2, hence- the version number 2.1.]-                             Preamble    The licenses for most software are designed to take away your freedom to share and change it.  By contrast, the GNU General Public-Licenses are intended to guarantee your freedom to share and change-free software--to make sure the software is free for all its users.--  This license, the Lesser General Public License, applies to some-specially designated software packages--typically libraries--of the-Free Software Foundation and other authors who decide to use it.  You-can use it too, but we suggest you first think carefully about whether-this license or the ordinary General Public License is the better-strategy to use in any particular case, based on the explanations below.+License is intended to guarantee your freedom to share and change free+software--to make sure the software is free for all its users.  This+General Public License applies to most of the Free Software+Foundation's software and to any other program whose authors commit to+using it.  (Some other Free Software Foundation software is covered by+the GNU Lesser General Public License instead.)  You can apply it to+your programs, too. -  When we speak of free software, we are referring to freedom of use,-not price.  Our General Public Licenses are designed to make sure that-you have the freedom to distribute copies of free software (and charge-for this service if you wish); that you receive source code or can get-it if you want it; that you can change the software and use pieces of-it in new free programs; and that you are informed that you can do-these things.+  When we speak of free software, we are referring to freedom, not+price.  Our General Public Licenses are designed to make sure that you+have the freedom to distribute copies of free software (and charge for+this service if you wish), that you receive source code or can get it+if you want it, that you can change the software or use pieces of it+in new free programs; and that you know you can do these things.    To protect your rights, we need to make restrictions that forbid-distributors to deny you these rights or to ask you to surrender these-rights.  These restrictions translate to certain responsibilities for-you if you distribute copies of the library or if you modify it.--  For example, if you distribute copies of the library, whether gratis-or for a fee, you must give the recipients all the rights that we gave-you.  You must make sure that they, too, receive or can get the source-code.  If you link other code with the library, you must provide-complete object files to the recipients, so that they can relink them-with the library after making changes to the library and recompiling-it.  And you must show them these terms so they know their rights.--  We protect your rights with a two-step method: (1) we copyright the-library, and (2) we offer you this license, which gives you legal-permission to copy, distribute and/or modify the library.--  To protect each distributor, we want to make it very clear that-there is no warranty for the free library.  Also, if the library is-modified by someone else and passed on, the recipients should know-that what they have is not the original version, so that the original-author's reputation will not be affected by problems that might be-introduced by others.--  Finally, software patents pose a constant threat to the existence of-any free program.  We wish to make sure that a company cannot-effectively restrict the users of a free program by obtaining a-restrictive license from a patent holder.  Therefore, we insist that-any patent license obtained for a version of the library must be-consistent with the full freedom of use specified in this license.--  Most GNU software, including some libraries, is covered by the-ordinary GNU General Public License.  This license, the GNU Lesser-General Public License, applies to certain designated libraries, and-is quite different from the ordinary General Public License.  We use-this license for certain libraries in order to permit linking those-libraries into non-free programs.--  When a program is linked with a library, whether statically or using-a shared library, the combination of the two is legally speaking a-combined work, a derivative of the original library.  The ordinary-General Public License therefore permits such linking only if the-entire combination fits its criteria of freedom.  The Lesser General-Public License permits more lax criteria for linking other code with-the library.+anyone to deny you these rights or to ask you to surrender the rights.+These restrictions translate to certain responsibilities for you if you+distribute copies of the software, or if you modify it. -  We call this license the "Lesser" General Public License because it-does Less to protect the user's freedom than the ordinary General-Public License.  It also provides other free software developers Less-of an advantage over competing non-free programs.  These disadvantages-are the reason we use the ordinary General Public License for many-libraries.  However, the Lesser license provides advantages in certain-special circumstances.+  For example, if you distribute copies of such a program, whether+gratis or for a fee, you must give the recipients all the rights that+you have.  You must make sure that they, too, receive or can get the+source code.  And you must show them these terms so they know their+rights. -  For example, on rare occasions, there may be a special need to-encourage the widest possible use of a certain library, so that it becomes-a de-facto standard.  To achieve this, non-free programs must be-allowed to use the library.  A more frequent case is that a free-library does the same job as widely used non-free libraries.  In this-case, there is little to gain by limiting the free library to free-software only, so we use the Lesser General Public License.+  We protect your rights with two steps: (1) copyright the software, and+(2) offer you this license which gives you legal permission to copy,+distribute and/or modify the software. -  In other cases, permission to use a particular library in non-free-programs enables a greater number of people to use a large body of-free software.  For example, permission to use the GNU C Library in-non-free programs enables many more people to use the whole GNU-operating system, as well as its variant, the GNU/Linux operating-system.+  Also, for each author's protection and ours, we want to make certain+that everyone understands that there is no warranty for this free+software.  If the software is modified by someone else and passed on, we+want its recipients to know that what they have is not the original, so+that any problems introduced by others will not reflect on the original+authors' reputations. -  Although the Lesser General Public License is Less protective of the-users' freedom, it does ensure that the user of a program that is-linked with the Library has the freedom and the wherewithal to run-that program using a modified version of the Library.+  Finally, any free program is threatened constantly by software+patents.  We wish to avoid the danger that redistributors of a free+program will individually obtain patent licenses, in effect making the+program proprietary.  To prevent this, we have made it clear that any+patent must be licensed for everyone's free use or not licensed at all.    The precise terms and conditions for copying, distribution and-modification follow.  Pay close attention to the difference between a-"work based on the library" and a "work that uses the library".  The-former contains code derived from the library, whereas the latter must-be combined with the library in order to run.--                  GNU LESSER GENERAL PUBLIC LICENSE-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION--  0. This License Agreement applies to any software library or other-program which contains a notice placed by the copyright holder or-other authorized party saying it may be distributed under the terms of-this Lesser General Public License (also called "this License").-Each licensee is addressed as "you".--  A "library" means a collection of software functions and/or data-prepared so as to be conveniently linked with application programs-(which use some of those functions and data) to form executables.+modification follow. -  The "Library", below, refers to any such software library or work-which has been distributed under these terms.  A "work based on the-Library" means either the Library or any derivative work under-copyright law: that is to say, a work containing the Library or a-portion of it, either verbatim or with modifications and/or translated-straightforwardly into another language.  (Hereinafter, translation is-included without limitation in the term "modification".)+                    GNU GENERAL PUBLIC LICENSE+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION -  "Source code" for a work means the preferred form of the work for-making modifications to it.  For a library, complete source code means-all the source code for all modules it contains, plus any associated-interface definition files, plus the scripts used to control compilation-and installation of the library.+  0. This License applies to any program or other work which contains+a notice placed by the copyright holder saying it may be distributed+under the terms of this General Public License.  The "Program", below,+refers to any such program or work, and a "work based on the Program"+means either the Program or any derivative work under copyright law:+that is to say, a work containing the Program or a portion of it,+either verbatim or with modifications and/or translated into another+language.  (Hereinafter, translation is included without limitation in+the term "modification".)  Each licensee is addressed as "you". -  Activities other than copying, distribution and modification are not+Activities other than copying, distribution and modification are not covered by this License; they are outside its scope.  The act of-running a program using the Library is not restricted, and output from-such a program is covered only if its contents constitute a work based-on the Library (independent of the use of the Library in a tool for-writing it).  Whether that is true depends on what the Library does-and what the program that uses the Library does.+running the Program is not restricted, and the output from the Program+is covered only if its contents constitute a work based on the+Program (independent of having been made by running the Program).+Whether that is true depends on what the Program does. -  1. You may copy and distribute verbatim copies of the Library's-complete source code as you receive it, in any medium, provided that-you conspicuously and appropriately publish on each copy an-appropriate copyright notice and disclaimer of warranty; keep intact-all the notices that refer to this License and to the absence of any-warranty; and distribute a copy of this License along with the-Library.+  1. You may copy and distribute verbatim copies of the Program's+source code as you receive it, in any medium, provided that you+conspicuously and appropriately publish on each copy an appropriate+copyright notice and disclaimer of warranty; keep intact all the+notices that refer to this License and to the absence of any warranty;+and give any other recipients of the Program a copy of this License+along with the Program. -  You may charge a fee for the physical act of transferring a copy,-and you may at your option offer warranty protection in exchange for a-fee.--  2. You may modify your copy or copies of the Library or any portion-of it, thus forming a work based on the Library, and copy and+You may charge a fee for the physical act of transferring a copy, and+you may at your option offer warranty protection in exchange for a fee.++  2. You may modify your copy or copies of the Program or any portion+of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: -    a) The modified work must itself be a software library.--    b) You must cause the files modified to carry prominent notices+    a) You must cause the modified files to carry prominent notices     stating that you changed the files and the date of any change. -    c) You must cause the whole of the work to be licensed at no-    charge to all third parties under the terms of this License.--    d) If a facility in the modified Library refers to a function or a-    table of data to be supplied by an application program that uses-    the facility, other than as an argument passed when the facility-    is invoked, then you must make a good faith effort to ensure that,-    in the event an application does not supply such function or-    table, the facility still operates, and performs whatever part of-    its purpose remains meaningful.+    b) You must cause any work that you distribute or publish, that in+    whole or in part contains or is derived from the Program or any+    part thereof, to be licensed as a whole at no charge to all third+    parties under the terms of this License. -    (For example, a function in a library to compute square roots has-    a purpose that is entirely well-defined independent of the-    application.  Therefore, Subsection 2d requires that any-    application-supplied function or table used by this function must-    be optional: if the application does not supply it, the square-    root function must still compute square roots.)+    c) If the modified program normally reads commands interactively+    when run, you must cause it, when started running for such+    interactive use in the most ordinary way, to print or display an+    announcement including an appropriate copyright notice and a+    notice that there is no warranty (or else, saying that you provide+    a warranty) and that users may redistribute the program under+    these conditions, and telling the user how to view a copy of this+    License.  (Exception: if the Program itself is interactive but+    does not normally print such an announcement, your work based on+    the Program is not required to print an announcement.)  These requirements apply to the modified work as a whole.  If-identifiable sections of that work are not derived from the Library,+identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works.  But when you distribute the same sections as part of a whole which is a work based-on the Library, the distribution of the whole must be on the terms of+on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the-entire whole, and thus to each and every part regardless of who wrote-it.+entire whole, and thus to each and every part regardless of who wrote it.  Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or-collective works based on the Library.+collective works based on the Program. -In addition, mere aggregation of another work not based on the Library-with the Library (or with a work based on the Library) on a volume of+In addition, mere aggregation of another work not based on the Program+with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. -  3. You may opt to apply the terms of the ordinary GNU General Public-License instead of this License to a given copy of the Library.  To do-this, you must alter all the notices that refer to this License, so-that they refer to the ordinary GNU General Public License, version 2,-instead of to this License.  (If a newer version than version 2 of the-ordinary GNU General Public License has appeared, then you can specify-that version instead if you wish.)  Do not make any other change in-these notices.--  Once this change is made in a given copy, it is irreversible for-that copy, so the ordinary GNU General Public License applies to all-subsequent copies and derivative works made from that copy.--  This option is useful when you wish to copy part of the code of-the Library into a program that is not a library.--  4. You may copy and distribute the Library (or a portion or-derivative of it, under Section 2) in object code or executable form-under the terms of Sections 1 and 2 above provided that you accompany-it with the complete corresponding machine-readable source code, which-must be distributed under the terms of Sections 1 and 2 above on a-medium customarily used for software interchange.--  If distribution of object code is made by offering access to copy-from a designated place, then offering equivalent access to copy the-source code from the same place satisfies the requirement to-distribute the source code, even though third parties are not-compelled to copy the source along with the object code.--  5. A program that contains no derivative of any portion of the-Library, but is designed to work with the Library by being compiled or-linked with it, is called a "work that uses the Library".  Such a-work, in isolation, is not a derivative work of the Library, and-therefore falls outside the scope of this License.--  However, linking a "work that uses the Library" with the Library-creates an executable that is a derivative of the Library (because it-contains portions of the Library), rather than a "work that uses the-library".  The executable is therefore covered by this License.-Section 6 states terms for distribution of such executables.--  When a "work that uses the Library" uses material from a header file-that is part of the Library, the object code for the work may be a-derivative work of the Library even though the source code is not.-Whether this is true is especially significant if the work can be-linked without the Library, or if the work is itself a library.  The-threshold for this to be true is not precisely defined by law.--  If such an object file uses only numerical parameters, data-structure layouts and accessors, and small macros and small inline-functions (ten lines or less in length), then the use of the object-file is unrestricted, regardless of whether it is legally a derivative-work.  (Executables containing this object code plus portions of the-Library will still fall under Section 6.)--  Otherwise, if the work is a derivative of the Library, you may-distribute the object code for the work under the terms of Section 6.-Any executables containing that work also fall under Section 6,-whether or not they are linked directly with the Library itself.--  6. As an exception to the Sections above, you may also combine or-link a "work that uses the Library" with the Library to produce a-work containing portions of the Library, and distribute that work-under terms of your choice, provided that the terms permit-modification of the work for the customer's own use and reverse-engineering for debugging such modifications.--  You must give prominent notice with each copy of the work that the-Library is used in it and that the Library and its use are covered by-this License.  You must supply a copy of this License.  If the work-during execution displays copyright notices, you must include the-copyright notice for the Library among them, as well as a reference-directing the user to the copy of this License.  Also, you must do one-of these things:--    a) Accompany the work with the complete corresponding-    machine-readable source code for the Library including whatever-    changes were used in the work (which must be distributed under-    Sections 1 and 2 above); and, if the work is an executable linked-    with the Library, with the complete machine-readable "work that-    uses the Library", as object code and/or source code, so that the-    user can modify the Library and then relink to produce a modified-    executable containing the modified Library.  (It is understood-    that the user who changes the contents of definitions files in the-    Library will not necessarily be able to recompile the application-    to use the modified definitions.)--    b) Use a suitable shared library mechanism for linking with the-    Library.  A suitable mechanism is one that (1) uses at run time a-    copy of the library already present on the user's computer system,-    rather than copying library functions into the executable, and (2)-    will operate properly with a modified version of the library, if-    the user installs one, as long as the modified version is-    interface-compatible with the version that the work was made with.--    c) Accompany the work with a written offer, valid for at-    least three years, to give the same user the materials-    specified in Subsection 6a, above, for a charge no more-    than the cost of performing this distribution.--    d) If distribution of the work is made by offering access to copy-    from a designated place, offer equivalent access to copy the above-    specified materials from the same place.+  3. You may copy and distribute the Program (or a work based on it,+under Section 2) in object code or executable form under the terms of+Sections 1 and 2 above provided that you also do one of the following: -    e) Verify that the user has already received a copy of these-    materials or that you have already sent this user a copy.+    a) Accompany it with the complete corresponding machine-readable+    source code, which must be distributed under the terms of Sections+    1 and 2 above on a medium customarily used for software interchange; or, -  For an executable, the required form of the "work that uses the-Library" must include any data and utility programs needed for-reproducing the executable from it.  However, as a special exception,-the materials to be distributed need not include anything that is-normally distributed (in either source or binary form) with the major-components (compiler, kernel, and so on) of the operating system on-which the executable runs, unless that component itself accompanies-the executable.+    b) Accompany it with a written offer, valid for at least three+    years, to give any third party, for a charge no more than your+    cost of physically performing source distribution, a complete+    machine-readable copy of the corresponding source code, to be+    distributed under the terms of Sections 1 and 2 above on a medium+    customarily used for software interchange; or, -  It may happen that this requirement contradicts the license-restrictions of other proprietary libraries that do not normally-accompany the operating system.  Such a contradiction means you cannot-use both them and the Library together in an executable that you-distribute.--  7. 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 not covered by this License, and distribute such a combined-library, provided that the separate distribution of the work based on-the Library and of the other library facilities is otherwise-permitted, and provided that you do these two things:+    c) Accompany it with the information you received as to the offer+    to distribute corresponding source code.  (This alternative is+    allowed only for noncommercial distribution and only if you+    received the program in object code or executable form with such+    an offer, in accord with Subsection b above.) -    a) Accompany the combined library with a copy of the same work-    based on the Library, uncombined with any other library-    facilities.  This must be distributed under the terms of the-    Sections above.+The source code for a work means the preferred form of the work for+making modifications to it.  For an executable work, complete source+code means all the source code for all modules it contains, plus any+associated interface definition files, plus the scripts used to+control compilation and installation of the executable.  However, as a+special exception, the source code distributed need not include+anything that is normally distributed (in either source or binary+form) with the major components (compiler, kernel, and so on) of the+operating system on which the executable runs, unless that component+itself accompanies the executable. -    b) Give prominent notice with the combined library of the fact-    that part of it is a work based on the Library, and explaining-    where to find the accompanying uncombined form of the same work.+If distribution of executable or object code is made by offering+access to copy from a designated place, then offering equivalent+access to copy the source code from the same place counts as+distribution of the source code, even though third parties are not+compelled to copy the source along with the object code. -  8. You may not copy, modify, sublicense, link with, or distribute-the Library except as expressly provided under this License.  Any-attempt otherwise to copy, modify, sublicense, link with, or-distribute the Library is void, and will automatically terminate your-rights under this License.  However, parties who have received copies,-or rights, from you under this License will not have their licenses-terminated so long as such parties remain in full compliance.+  4. You may not copy, modify, sublicense, or distribute the Program+except as expressly provided under this License.  Any attempt+otherwise to copy, modify, sublicense or distribute the Program is+void, and will automatically terminate your rights under this License.+However, parties who have received copies, or rights, from you under+this License will not have their licenses terminated so long as such+parties remain in full compliance. -  9. You are not required to accept this License, since you have not+  5. You are not required to accept this License, since you have not signed it.  However, nothing else grants you permission to modify or-distribute the Library or its derivative works.  These actions are+distribute the Program or its derivative works.  These actions are prohibited by law if you do not accept this License.  Therefore, by-modifying or distributing the Library (or any work based on the-Library), you indicate your acceptance of this License to do so, and+modifying or distributing the Program (or any work based on the+Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying-the Library or works based on it.+the Program or works based on it. -  10. Each time you redistribute the Library (or any work based on the-Library), the recipient automatically receives a license from the-original licensor to copy, distribute, link with or modify the Library-subject to these terms and conditions.  You may not impose any further+  6. Each time you redistribute the Program (or any work based on the+Program), the recipient automatically receives a license from the+original licensor to copy, distribute or modify the Program subject to+these terms and conditions.  You may not impose any further restrictions on the recipients' exercise of the rights granted herein.-You are not responsible for enforcing compliance by third parties with+You are not responsible for enforcing compliance by third parties to this License.--  11. If, as a consequence of a court judgment or allegation of patent++  7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you-may not distribute the Library at all.  For example, if a patent-license would not permit royalty-free redistribution of the Library by+may not distribute the Program at all.  For example, if a patent+license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to-refrain entirely from distribution of the Library.+refrain entirely from distribution of the Program. -If any portion of this section is held invalid or unenforceable under any-particular circumstance, the balance of the section is intended to apply,-and the section as a whole is intended to apply in other circumstances.+If any portion of this section is held invalid or unenforceable under+any particular circumstance, the balance of the section is intended to+apply and the section as a whole is intended to apply in other+circumstances.  It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the-integrity of the free software distribution system which is+integrity of the free software distribution system, which is implemented by public license practices.  Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that@@ -402,101 +226,114 @@ This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. -  12. If the distribution and/or use of the Library is restricted in+  8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the-original copyright holder who places the Library under this License may add-an explicit geographical distribution limitation excluding those countries,-so that distribution is permitted only in or among countries not thus-excluded.  In such case, this License incorporates the limitation as if-written in the body of this License.+original copyright holder who places the Program under this License+may add an explicit geographical distribution limitation excluding+those countries, so that distribution is permitted only in or among+countries not thus excluded.  In such case, this License incorporates+the limitation as if written in the body of this License. -  13. The Free Software Foundation may publish revised and/or new-versions of the 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.+  9. The Free Software Foundation may publish revised and/or new versions+of the 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-specifies a version number of this License which applies to it and-"any later version", you have the option of following the terms and-conditions either of that version or of any later version published by-the Free Software Foundation.  If the Library does not specify a-license version number, you may choose any version ever published by-the Free Software Foundation.--  14. If you wish to incorporate parts of the Library into other free-programs whose distribution conditions are incompatible with these,-write to the author to ask for permission.  For software which is-copyrighted by the Free Software Foundation, write to the Free-Software Foundation; we sometimes make exceptions for this.  Our-decision will be guided by the two goals of preserving the free status-of all derivatives of our free software and of promoting the sharing-and reuse of software generally.+Each version is given a distinguishing version number.  If the Program+specifies a version number of this License which applies to it and "any+later version", you have the option of following the terms and conditions+either of that version or of any later version published by the Free+Software Foundation.  If the Program does not specify a version number of+this License, you may choose any version ever published by the Free Software+Foundation. +  10. If you wish to incorporate parts of the Program into other free+programs whose distribution conditions are different, write to the author+to ask for permission.  For software which is copyrighted by the Free+Software Foundation, write to the Free Software Foundation; we sometimes+make exceptions for this.  Our decision will be guided by the two goals+of preserving the free status of all derivatives of our free software and+of promoting the sharing and reuse of software generally.+                             NO WARRANTY -  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,+REPAIR OR CORRECTION. -  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH-DAMAGES.+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE+POSSIBILITY OF SUCH DAMAGES.                       END OF TERMS AND CONDITIONS--           How to Apply These Terms to Your New Libraries -  If you develop a new library, and you want it to be of the greatest-possible use to the public, we recommend making it free software that-everyone can redistribute and change.  You can do so by permitting-redistribution under these terms (or, alternatively, under the terms of the-ordinary General Public License).+            How to Apply These Terms to Your New Programs -  To apply these terms, attach the following notices to the library.  It is-safest to attach them to the start of each source file to most effectively-convey the exclusion of warranty; and each file should have at least the-"copyright" line and a pointer to where the full notice is found.+  If you develop a new program, and you want it to be of the greatest+possible use to the public, the best way to achieve this is to make it+free software which everyone can redistribute and change under these terms. -    <one line to give the library's name and a brief idea of what it does.>+  To do so, attach the following notices to the program.  It is safest+to attach them to the start of each source file to most effectively+convey the exclusion of warranty; and each file should have at least+the "copyright" line and a pointer to where the full notice is found.++    <one line to give the program's name and a brief idea of what it does.>     Copyright (C) <year>  <name of author> -    This library is free software; you can redistribute it and/or-    modify it under the terms of the GNU Lesser General Public-    License as published by the Free Software Foundation; either-    version 2.1 of the License, or (at your option) any later version.+    This program is free software; you can redistribute it and/or modify+    it under the terms of the GNU General Public License as published by+    the Free Software Foundation; either version 2 of the License, or+    (at your option) any later version. -    This library is distributed in the hope that it will be useful,+    This program is distributed in the hope that it will be useful,     but WITHOUT ANY WARRANTY; without even the implied warranty of-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU-    Lesser General Public License for more details.+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the+    GNU General Public License for more details. -    You should have received a copy of the GNU Lesser General Public-    License along with this library; if not, write to the Free Software-    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA+    You should have received a copy of the GNU General Public License along+    with this program; if not, write to the Free Software Foundation, Inc.,+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.  Also add information on how to contact you by electronic and paper mail. +If the program is interactive, make it output a short notice like this+when it starts in an interactive mode:++    Gnomovision version 69, Copyright (C) year name of author+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.+    This is free software, and you are welcome to redistribute it+    under certain conditions; type `show c' for details.++The hypothetical commands `show w' and `show c' should show the appropriate+parts of the General Public License.  Of course, the commands you use may+be called something other than `show w' and `show c'; they could even be+mouse-clicks or menu items--whatever suits your program.+ You should also get your employer (if you work as a programmer) or your-school, if any, to sign a "copyright disclaimer" for the library, if+school, if any, to sign a "copyright disclaimer" for the program, if necessary.  Here is a sample; alter the names: -  Yoyodyne, Inc., hereby disclaims all copyright interest in the-  library `Frob' (a library for tweaking knobs) written by James Random Hacker.+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program+  `Gnomovision' (which makes passes at compilers) written by James Hacker. -  <signature of Ty Coon>, 1 April 1990+  <signature of Ty Coon>, 1 April 1989   Ty Coon, President of Vice -That's all there is to it!+This General Public License does not permit incorporating your program into+proprietary programs.  If your program is a subroutine library, you may+consider it more useful to permit linking proprietary applications with the+library.  If this is what you want to do, use the GNU Lesser General+Public License instead of this License.

@@ -1,3 +1,5 @@+![examples of complex_plot in Flint2-examples](/docs/out.png)+ # Flint2 **Flint2** provides a thin Haskell wrapper for [Flint](https://flintlib.org) C-library.  @@ -9,46 +11,27 @@ - Install the Haskell interface with  ```bash-cabal install Flint2+cabal install Flint2 --lib ``` +The depencies are minimal. Flint2 relies on just three libraries:+QuickCheck, groups, containers.+ ## Quick Start -A simple program using the thin wrapper would be+A simple example for the application of the library is the+factorization of $2^{256}-1$:  ```haskell import Data.Number.Flint -main = do -  x <- newFmpz-  y <- newFmpz-  withFmpz x $ \x -> do-    withFmpz y $ \y -> do-      fmpz_set_ui x 7-      fmpz_set_ui y 6-      fmpz_mul x x y-      fmpz_print x  -```--which will print the numerical value 42.--In the app directory more practical information on how to use the thin wrapper can be found. -The above example simplifies to --```haskell-include Fmpz--main = do-  let x = 7 :: Fmpz -      y = 6 :: Fmpz-  print $ x*y-  print $ factor (42 :: Fmpz)-  +main = print $ factor (2^256 - 1 :: Fmpz) ``` -which prints +runnnig main prints   ```-42 -[(2,1),(3,1),(7,1)]+[(3,1),(5,1),(17,1),(257,1),(641,1),(65537,1),(274177,1),(6700417,1),(67280421310721,1),(59649589127497217,1),(5704689200685129054721,1)] ```++examples can be found soon in **FLINT2-Examples**.

@@ -4,6 +4,8 @@ #include <flint/arb.h>  arf_struct * arb_midref_(arb_t x);+mag_struct * arb_radref_(arb_t x);+ char * arb_get_str_(const arb_t x); char * arb_get_strd(const arb_t x, slong digits); char * arb_get_strn(const arb_t x, slong digits, ulong options);

@@ -0,0 +1,12 @@+#include <stdlib.h>+#include <stdio.h>+#include <string.h>++#include <flint/flint.h>+#include <flint/arb.h>++#include "../arb.h"++mag_struct * arb_radref_(arb_t x) {+  return &(x->rad);+}

@@ -0,0 +1,76 @@+/*+  Copyright (C) 2020 Fredrik Johansson++  This file is part of Calcium.++  Calcium is free software: you can redistribute it and/or modify it under+  the terms of the GNU Lesser General Public License (LGPL) as published+  by the Free Software Foundation; either version 2.1 of the License, or+  (at your option) any later version.  See <http://www.gnu.org/licenses/>.+*/++#include <stdio.h>+#include <flint/flint.h>+#include <flint/ca_ext.h>++#include "../qqbar.h"+#include "../ca_ext.h"++void+ca_ext_fprint(FILE *file, const ca_ext_t x, ca_ctx_t ctx)+{+  if (x->head == CA_QQBar)+    {+      flint_fprintf(file, "Algebraic ");++      if (qqbar_is_i(CA_EXT_QQBAR(x)))+	flint_fprintf(file, "I");+      else+        {+	  /*+            flint_fprintf(file, "Algebraic [deg %wd] ", qqbar_degree(CA_EXT_QQBAR(x)));+            qqbar_printn(CA_EXT_QQBAR(x), 10);+	  */++	  qqbar_fprintn(file, CA_EXT_QQBAR(x), 8);+	  /*+            flint_fprintf(file, " (");+            fmpz_poly_print_pretty(QQBAR_POLY(CA_EXT_QQBAR(x)), "a");+            flint_fprintf(file, "=0)");+	  */+        }+    }+  else+    {+      flint_fprintf(file, "%s", calcium_func_name(CA_EXT_HEAD(x)));++      if (CA_EXT_FUNC_NARGS(x) != 0)+        {+	  slong i;+	  flint_fprintf(file, "(");+	  for (i = 0; i < CA_EXT_FUNC_NARGS(x); i++)+            {+	      ca_fprint(file, CA_EXT_FUNC_ARGS(x) + i, ctx);++	      if (i < CA_EXT_FUNC_NARGS(x) - 1)+		flint_fprintf(file, ", ");+            }+	  flint_fprintf(file, ")");+        }+    }+}++char*+ca_ext_get_str(const ca_ext_t x, ca_ctx_t ctx)+{+   char * buffer = NULL;+   size_t buffer_size = 0;++   FILE * out = open_memstream(&buffer, &buffer_size);++   ca_ext_fprint(out, x, ctx);++   fclose(out);++   return buffer;+}

@@ -0,0 +1,50 @@+#include <stdlib.h>+#include <stdio.h>+#include <string.h>++#include <stdio.h>+#include <flint/flint.h>+#include <flint/ca.h>+#include <flint/ca_mat.h>++#include "../ca_mat.h"++char*+ca_mat_get_str(const ca_mat_t mat, ca_ctx_t ctx)+{+  char * buffer = NULL;+  size_t buffer_size = 0;++  FILE * out = open_memstream(&buffer, &buffer_size);++  ca_mat_fprint(out, mat, ctx);++  fclose(out);++  return buffer;+}++void+ca_mat_fprint(FILE *file, const ca_mat_t mat, ca_ctx_t ctx)+{+  slong r, c;+  slong i, j;++  r = ca_mat_nrows(mat);+  c = ca_mat_ncols(mat);++  flint_fprintf(file, "ca_mat of size %wd x %wd:\n", r, c);++  for (i = 0; i < r; i++)+    {+      for (j = 0; j < c; j++)+        {+	  flint_fprintf(file, "    ");+	  ca_fprint(file, ca_mat_entry(mat, i, j), ctx);+	  flint_fprintf(file, "\n");+        }++    }++  flint_fprintf(file, "\n");+}

@@ -0,0 +1,46 @@+/*+    Copyright (C) 2020 Fredrik Johansson++    This file is part of Calcium.++    Calcium is free software: you can redistribute it and/or modify it under+    the terms of the GNU Lesser General Public License (LGPL) as published+    by the Free Software Foundation; either version 2.1 of the License, or+    (at your option) any later version.  See <http://www.gnu.org/licenses/>.+*/++#include "ca_poly.h"++void+ca_poly_fprint(FILE *file, const ca_poly_t poly, ca_ctx_t ctx)+{+    slong i, len;++    len = poly->length;++    flint_fprintf(file, "ca_poly of length %wd:\n", len);++    for (i = 0; i < len; i++)+    {+      char *str = ca_get_str(poly->coeffs + i, ctx);+      flint_fprintf(file, "    %s\n", str);+      flint_free(str);+    }++    flint_fprintf(file, "\n");+}++char*+ca_poly_get_str(const ca_poly_t poly, ca_ctx_t ctx)+{+   char * buffer = NULL;+   size_t buffer_size = 0;++   FILE * out = open_memstream(&buffer, &buffer_size);++   ca_poly_fprint(out, poly, ctx);++   fclose(out);++   return buffer;+}

@@ -0,0 +1,16 @@+#ifndef CSRC_DIRICHLET_H_+#define CSRC_DIRICHLET_H_++#include <stdlib.h>+#include <flint/dirichlet.h>++void+dirichlet_char_fprint(FILE *file,+		      const dirichlet_group_t G,+		      const dirichlet_char_t x);++char*+dirichlet_char_get_str(const dirichlet_group_t G,+		       const dirichlet_char_t x);++#endif // CSRC_DIRICHLET_H_

@@ -0,0 +1,47 @@+/*+  Copyright (C) 2022 Hartmut Monien++  This file is part of Arb.++  Arb is free software: you can redistribute it and/or modify it under+  the terms of the GNU Lesser General Public License (LGPL) as published+  by the Free Software Foundation; either version 2.1 of the License, or+  (at your option) any later version.  See <http://www.gnu.org/licenses/>.+*/++#include <stdlib.h>+#include <flint/dirichlet.h>++#include "dirichlet.h"++void+dirichlet_char_fprint(FILE *file,+		      const dirichlet_group_t G,+		      const dirichlet_char_t x)+{+  slong k;+  if (G->num)+    flint_fprintf(file, "[%wu", x->log[0]);+  else+    flint_printf("[");+  for (k = 1; k < G->num; k++)+    flint_fprintf(file, ", %wu", x->log[k]);+  flint_fprintf(file, "]");+}++char*+dirichlet_char_get_str(const dirichlet_group_t G,+		       const dirichlet_char_t x)+{+   char * buffer = NULL;+   size_t buffer_size = 0;++   FILE * out = open_memstream(&buffer, &buffer_size);++   dirichlet_char_fprint(out, G, x);++   fclose(out);++   return buffer;+}+

@@ -0,0 +1,18 @@+#ifndef CSRC_FMPZ_MPOLY_FACTOR_H_+#define CSRC_FMPZ_MPOLY_FACTOR_H_++#include <stdio.h>+#include <flint/fmpz_mpoly_factor.h>++void+fmpz_mpoly_factor_fprint_pretty(FILE *file,+				const fmpz_mpoly_factor_t f,+                                const char ** vars,+				const fmpz_mpoly_ctx_t ctx);++char*+fmpz_mpoly_factor_get_str_pretty(const fmpz_mpoly_factor_t f,+				 const char ** vars,+				 const fmpz_mpoly_ctx_t ctx);++#endif 

@@ -0,0 +1,38 @@+#include <stdio.h>+#include <flint/fmpz_mpoly_factor.h>+++void+fmpz_mpoly_factor_fprint_pretty(FILE *file,+				const fmpz_mpoly_factor_t f,+                                const char ** vars,+				const fmpz_mpoly_ctx_t ctx) {+  slong i;+  +  fmpz_fprint(file, f->constant);+  for (i = 0; i < f->num; i++) {+    flint_fprintf(file, "*(", i);+    fmpz_mpoly_fprint_pretty(file, f->poly + i, vars, ctx);+    flint_fprintf(file, ")^");+    fmpz_fprint(file, f->exp + i);+  }++  +}++char*+fmpz_mpoly_factor_get_str_pretty(const fmpz_mpoly_factor_t f,+				 const char ** vars,+				 const fmpz_mpoly_ctx_t ctx) {+   char * buffer = NULL;+   size_t buffer_size = 0;++   FILE * out = open_memstream(&buffer, &buffer_size);++   fmpz_mpoly_factor_fprint_pretty(out, f, vars, ctx);++   fclose(out);++   return buffer;+}+

@@ -1,10 +1,10 @@ name:                Flint2-version:             0.1.0.1+version:             0.1.0.2 github:              "monien/Flint2"-license:             BSD3+license:             GPL-2 author:              "Hartmut Monien" maintainer:        "hmonien@uni-bonn.de"-copyright:         "Copyright (c) 2022 Hartmut Monien"+copyright:         "Copyright (c) 2023 Hartmut Monien" category:           Math synopsis:          "Haskell bindings for the flint library for number theory" @@ -17,8 +17,30 @@  extra-doc-files:  docs/*.png -description:  Please see the README on GitHub at <https://github.com/monien/Flint2#readme>+description:+    A Haskell Wrapper for Flint+    +    This library provides access to the functionality of the FLINT. +    So what is it?+    +    FLINT is a C library for doing number theory, freely+    available under the GNU LGPL at+    [https://flintlib.org](https://flintlib.org)++    At its core, FLINT provides arithmetic in standard rings such as the+    integers, rationals, algebraic, real, complex and p-adic numbers,+    finite fields, and number fields. It also provides polynomials+    (univariate and multivariate), power series, and matrices.++    At the research frontier+      +    FLINT has been used for many large scale research computations+    (e.g. A Trillion Triangles) and has been cited in hundreds+    of publications. FLINT's authors themselves have published more+    than 20 papers describing new algorithms first implemented within+    or on top of FLINT.+ dependencies: - base >= 4.7 && < 5     @@ -157,6 +179,7 @@    - Data.Number.Flint.Arb    - Data.Number.Flint.Arb.Instances    - Data.Number.Flint.Arb.Mag+   - Data.Number.Flint.Arb.Mag.Instances    - Data.Number.Flint.Arb.Arf    - Data.Number.Flint.Arb.Poly    - Data.Number.Flint.Arb.Poly.Instances@@ -184,6 +207,18 @@    - Data.Number.Flint.Acb.DFT    - Data.Number.Flint.Acb.ComplexField    - Data.Number.Flint.Acb.Calc+   # Exact real and complex numbers+   - Data.Number.Flint.Calcium+   - Data.Number.Flint.Calcium.Ca+   - Data.Number.Flint.Calcium.Ca.Types+   - Data.Number.Flint.Calcium.Ca.Poly+   - Data.Number.Flint.Calcium.Ca.Vec+   - Data.Number.Flint.Calcium.Ca.Mat+   - Data.Number.Flint.Calcium.Ca.Field+   - Data.Number.Flint.Calcium.Ca.Ext+   - Data.Number.Flint.Calcium.Fexpr+   - Data.Number.Flint.Calcium.Fexpr.Instances+   - Data.Number.Flint.Calcium.Fexpr.Builtin    # Other    - Data.Number.Flint.Bernoulli     - Data.Number.Flint.Partitions@@ -318,6 +353,16 @@    - Data.Number.Flint.Acb.Dirichlet.FFI    - Data.Number.Flint.Acb.DFT.FFI    - Data.Number.Flint.Acb.Calc.FFI+   # Calcium+   - Data.Number.Flint.Calcium.FFI+   - Data.Number.Flint.Calcium.Ca.FFI+   - Data.Number.Flint.Calcium.Ca.Types.FFI+   - Data.Number.Flint.Calcium.Ca.Poly.FFI+   - Data.Number.Flint.Calcium.Ca.Vec.FFI+   - Data.Number.Flint.Calcium.Ca.Mat.FFI+   - Data.Number.Flint.Calcium.Ca.Field.FFI+   - Data.Number.Flint.Calcium.Ca.Ext.FFI+   - Data.Number.Flint.Calcium.Fexpr.FFI    # Other     - Data.Number.Flint.Bernoulli.FFI     - Data.Number.Flint.Partitions.FFI@@ -327,6 +372,7 @@    - Data.Number.Flint.NF.Elem.FFI    - Data.Number.Flint.NF.Fmpzi.FFI    - Data.Number.Flint.NF.QQbar.FFI+  include-dirs: csrc   install-includes:     - acb.h     - acb_mat.h@@ -341,6 +387,7 @@     - arf.h     - bool_mat.h     - d_mat.h+    - dirichlet.h     - double_interval.h     - fmpq.h     - fmpq_mat.h@@ -350,6 +397,7 @@     - fmpz_factor.h     - fmpz_mat.h     - fmpz_mod_poly_factor.h+    - fmpz_mpoly_factor.h     - fmpz_mpoly_q.h     - fmpz_poly_mat.h     - fmpz_vec.h@@ -381,6 +429,7 @@     - csrc/fmpz_poly_mat/fprint.c     - csrc/fmpz_poly_mat/get_str.c     - csrc/fmpz_factor/get_str.c+    - csrc/fmpz_mpoly_factor/io.c     - csrc/fmpz_mpoly_q/fprint.c     - csrc/fmpz_mpoly_q/get_str_pretty.c     - csrc/fmpz_vec/get_str.c@@ -411,6 +460,7 @@     - csrc/aprcl/get_str.c     # Groups     - csrc/bool_mat/get_str.c+    - csrc/dirichlet/io.c     - csrc/qfb/get_str.c     - csrc/qfb/fprint.c     - csrc/qqbar/fprint.c@@ -446,6 +496,7 @@     - csrc/d_mat/io.c     # arb     - csrc/arb/midref.c+    - csrc/arb/radref.c     - csrc/arf/inlines.c     - csrc/mag/get_str.c     - csrc/arb/get_strd.c@@ -471,6 +522,10 @@     - csrc/acb_modular/inlines.c     - csrc/acb_modular/get_str.c     - csrc/mpfr_mat/swap_entrywise.c+    # calcium+    - csrc/ca_poly/io.c+    - csrc/ca_mat/io.c+    - csrc/ca_ext/io.c     # word problem     - csrc/psl2z/word_problem.c     # perm@@ -478,13 +533,13 @@     - csrc/perm/print_pretty.c     - csrc/perm/power.c     - csrc/perm/mat.c-  include-dirs: csrc   build-tools: hsc2hs-  extra-libraries: flint, gmp+  extra-libraries: flint   pkgconfig-depends: flint >= 2.9, gmp   dependencies:-    - QuickCheck-    - groups+    - QuickCheck >= 2.14.3 && < 2.15+    - groups         >= 0.5.3 && < 0.6+    - containers   >= 0.6.5 && < 0.7    tests:   Flint2-test:

@@ -1,5 +1,3 @@-{-# OPTIONS_HADDOCK prune, ignore-exports #-}- {-| module      :  Data.Number.Flint.Flint copyright   :  (c) 2022 Hartmut Monien@@ -125,6 +123,7 @@ , module Data.Number.Flint.Arb , module Data.Number.Flint.Arb.RealField , module Data.Number.Flint.Arb.Mag+, module Data.Number.Flint.Arb.Mag.Instances , module Data.Number.Flint.Arb.Arf , module Data.Number.Flint.Arb.Poly , module Data.Number.Flint.Arb.Fmpz.Poly@@ -143,6 +142,17 @@ , module Data.Number.Flint.Acb.Dirichlet , module Data.Number.Flint.Acb.DFT , module Data.Number.Flint.Acb.Calc+-- ** Exact real and complex numbers+, module Data.Number.Flint.Calcium+, module Data.Number.Flint.Calcium.Ca+, module Data.Number.Flint.Calcium.Ca.Poly+, module Data.Number.Flint.Calcium.Ca.Vec+, module Data.Number.Flint.Calcium.Ca.Mat+, module Data.Number.Flint.Calcium.Ca.Field+, module Data.Number.Flint.Calcium.Ca.Ext+, module Data.Number.Flint.Calcium.Fexpr+, module Data.Number.Flint.Calcium.Fexpr.Instances+, module Data.Number.Flint.Calcium.Fexpr.Builtin -- ** Partitions , module Data.Number.Flint.Partitions -- ** Bernoulli numbers@@ -295,6 +305,16 @@ import Data.Number.Flint.Acb.DFT import Data.Number.Flint.Acb.ComplexField import Data.Number.Flint.Acb.Calc+-- Exact real and complex numbers+import Data.Number.Flint.Calcium+import Data.Number.Flint.Calcium.Ca+import Data.Number.Flint.Calcium.Ca.Poly+import Data.Number.Flint.Calcium.Ca.Vec+import Data.Number.Flint.Calcium.Ca.Mat+import Data.Number.Flint.Calcium.Ca.Field+import Data.Number.Flint.Calcium.Ca.Ext+import Data.Number.Flint.Calcium.Fexpr+import Data.Number.Flint.Calcium.Fexpr.Builtin -- Partitions import Data.Number.Flint.Partitions -- Bernoulli numbers@@ -328,6 +348,7 @@ import Data.Number.Flint.NMod.Poly.Instances  import Data.Number.Flint.Arb.Instances+import Data.Number.Flint.Arb.Mag.Instances import Data.Number.Flint.Arb.Poly.Instances import Data.Number.Flint.Arb.Mat.Instances @@ -340,3 +361,5 @@ import Data.Number.Flint.Groups.Bool.Mat.Instances  import Data.Number.Flint.Support.D.Mat.Instances++import Data.Number.Flint.Calcium.Fexpr.Instances

@@ -11,10 +11,14 @@   -- * Integration   , acb_calc_integrate   -- * Options for integration-  , AcbCalcIntegrateOpt ()-  , CAcbCalcIntegrateOpt+  , AcbCalcIntegrateOpt (..)+  , CAcbCalcIntegrateOpt (..)   , newAcbCalcIntegrateOpt+  , newAcbCalcIntegrateOpt_   , withAcbCalcIntegrateOpt+  , withNewAcbCalcIntegrateOpt+  , withNewAcbCalcIntegrateOpt_+  -- * Memory management   , acb_calc_integrate_opt_init   -- * Local integration algorithms   , acb_calc_integrate_gl_auto_deg@@ -61,19 +65,40 @@     <*> #{peek acb_calc_integrate_opt_struct, depth_limit} ptr     <*> #{peek acb_calc_integrate_opt_struct, use_heap   } ptr     <*> #{peek acb_calc_integrate_opt_struct, verbose    } ptr-  poke = error "CAcbCalcIntegrateOpt.poke undefined."-+  poke ptr (CAcbCalcIntegrateOpt deg eval depth heap verbose) = do+    (#poke acb_calc_integrate_opt_struct, deg_limit  ) ptr deg+    (#poke acb_calc_integrate_opt_struct, eval_limit ) ptr eval+    (#poke acb_calc_integrate_opt_struct, depth_limit) ptr depth+    (#poke acb_calc_integrate_opt_struct, use_heap   ) ptr heap+    (#poke acb_calc_integrate_opt_struct, verbose    ) ptr verbose+     newAcbCalcIntegrateOpt = do   x <- mallocForeignPtr   withForeignPtr x acb_calc_integrate_opt_init   return $ AcbCalcIntegrateOpt x +newAcbCalcIntegrateOpt_ deg eval depth heap verbose = do+  x <- mallocForeignPtr+  withForeignPtr x $ \x -> do+    acb_calc_integrate_opt_init x+    poke x (CAcbCalcIntegrateOpt deg eval depth heap verbose)+  return $ AcbCalcIntegrateOpt x+ withAcbCalcIntegrateOpt (AcbCalcIntegrateOpt x) f =   withForeignPtr x $ \xp -> f xp <&> (AcbCalcIntegrateOpt x,)-  ++withNewAcbCalcIntegrateOpt f = do+  x <- newAcbCalcIntegrateOpt+  withAcbCalcIntegrateOpt x f++withNewAcbCalcIntegrateOpt_ deg eval depth heap verbose f = do+  x <- newAcbCalcIntegrateOpt_ deg eval depth heap verbose+  withAcbCalcIntegrateOpt x f+ -- acb_calc_func_t ------------------------------------------------------------- -type CAcbCalcFunc = Ptr CAcb -> Ptr () -> CLong -> CLong+type CAcbCalcFunc =+  (Ptr CAcb -> Ptr CAcb -> Ptr () -> CLong -> CLong -> IO CInt)  -- Integration ----------------------------------------------------------------- 

@@ -14,6 +14,8 @@   , withNewAcb   , withAcbRe   , withAcbIm+  , acb_realref+  , acb_imagref   -- * Memory management   , acb_init   , acb_clear@@ -317,20 +319,34 @@ withAcbRe :: Acb -> (Ptr CArb -> IO t) -> IO (Acb, t) withAcbRe (Acb p) f = do    withForeignPtr p $ \fp -> do-     withForeignPtr p $ \fp -> (Acb p,) <$> f (castPtr fp)+     withForeignPtr p $ \fp -> (Acb p,) <$> f (acb_realref fp)  -- | Apply function `f` to imaginary part of `Acb` withAcbIm :: Acb -> (Ptr CArb -> IO t) -> IO (Acb, t) withAcbIm (Acb p) f = do    withForeignPtr p $ \fp -> do-     withForeignPtr p $ \fp -> (Acb p,) <$> f (castPtr fp `advancePtr` 1)+     withForeignPtr p $ \fp -> (Acb p,) <$> f (acb_imagref fp)  instance Storable CAcb where   sizeOf    _ = #{size      acb_t}   alignment _ = #{alignment acb_t}   peek = error "CAcb.peek not defined."   poke = error "CAcb.poke not defined."-  ++-- Access to real and imaginary part -------------------------------------------++-- | /acb_realref/ /z/+--+-- /acb_realref/ returns a `CArb` pointer to the real part of /z/.+acb_realref :: Ptr CAcb -> Ptr CArb+acb_realref z = castPtr z++-- | /acb_imagref/ /z/+--+-- /acb_imagref/ returns a `CArb` pointer to the imaginary part of /z/.+acb_imagref :: Ptr CAcb -> Ptr CArb+acb_imagref z = castPtr z `advancePtr` 1+ -- Memory management -----------------------------------------------------------  -- | /acb_init/ /x/ 

@@ -1,4 +1,3 @@-{-# OPTIONS_HADDOCK hide, prune, ignore-exports #-} module Data.Number.Flint.Acb.Instances where  import System.IO.Unsafe

@@ -1,4 +1,3 @@-{-# OPTIONS_HADDOCK hide, prune, ignore-exports #-} module Data.Number.Flint.Acb.Mat.Instances where  import System.IO.Unsafe

@@ -904,4 +904,3 @@ -- input, /res/ is set to the zero polynomial. foreign import ccall "acb_modular.h acb_modular_hilbert_class_poly"   acb_modular_hilbert_class_poly :: Ptr CFmpzPoly -> CLong -> IO ()-

@@ -1,4 +1,3 @@-{-# OPTIONS_HADDOCK hide, prune, ignore-exports #-} {-| module      :  Data.Number.Flint.Acb.Modular.Instances copyright   :  (c) 2022 Hartmut Monien

@@ -1,4 +1,3 @@-{-# OPTIONS_HADDOCK hide, prune, ignore-exports #-} module Data.Number.Flint.Acb.Poly.Instances (     AcbPoly (..)   , module GHC.Exts

@@ -1,4 +1,3 @@--- {-# OPTIONS_HADDOCK hide, prune, ignore-exports #-} module Data.Number.Flint.Acb.Types (   module Data.Number.Flint.Acb.Types.FFI   ) where

@@ -235,6 +235,7 @@  #define ARF_INLINES_C #include <flint/arf.h>+#include <flint/arb_calc.h>  -- arf_t ----------------------------------------------------------------------- @@ -252,7 +253,7 @@ withNewArf f = do   x <- newArf   withArf x $ \x -> f x-  +  -- Memory management -----------------------------------------------------------  -- | /arf_init/ /x/ 

@@ -10,6 +10,7 @@   , CArfInterval (..)   , newArfInterval   , withArfInterval+  , withNewArfInterval   , CArbCalcFunc   , arf_interval_init   , arf_interval_clear@@ -26,6 +27,10 @@   , arb_calc_newton_conv_factor   , arb_calc_newton_step   , arb_calc_refine_root_newton+  -- * Return types+  , arb_calc_success +  , arb_calc_imprecise_input +  , arb_calc_no_convergence ) where  -- Calculus with real-valued functions -----------------------------------------@@ -48,6 +53,7 @@  #include <flint/flint.h> #include <flint/arf_types.h>+#include <flint/arb_calc.h>  -- arf_interval_t -------------------------------------------------------------- @@ -80,8 +86,18 @@  -- arb_calc_func_t ------------------------------------------------------------- -type CArbCalcFunc = Ptr CArb -> Ptr CArb -> Ptr () -> CLong -> CLong+type CArbCalcFunc = Ptr CArb -> Ptr CArb -> Ptr () -> CLong -> CLong -> IO CInt +-- arb_calc_returns ------------------------------------------------------------++type ArbCalcReturn = CInt++arb_calc_success, arb_calc_imprecise_input, arb_calc_no_convergence :: ArbCalcReturn++arb_calc_success = #const ARB_CALC_SUCCESS+arb_calc_imprecise_input = #const ARB_CALC_IMPRECISE_INPUT+arb_calc_no_convergence = #const ARB_CALC_NO_CONVERGENCE+ -- Subdivision-based root finding ----------------------------------------------  -- | /arf_interval_init/ /v/ @@ -189,7 +205,7 @@ -- represented exactly as floating-point numbers in memory. Do not pass -- \(1 \pm 2^{-10^{100}}\) as input. foreign import ccall "arb_calc.h arb_calc_isolate_roots"-  arb_calc_isolate_roots :: Ptr (Ptr CArfInterval) -> Ptr (Ptr CInt) -> FunPtr CArbCalcFunc -> Ptr () -> Ptr CArfInterval -> CLong -> CLong -> CLong -> CLong -> IO CLong+  arb_calc_isolate_roots :: Ptr (Ptr CArfInterval) -> Ptr (Ptr CInt)-> FunPtr CArbCalcFunc -> Ptr () -> Ptr CArfInterval -> CLong -> CLong -> CLong -> CLong -> IO CLong  -- | /arb_calc_refine_root_bisect/ /r/ /func/ /param/ /start/ /iter/ /prec/  --

@@ -19,6 +19,7 @@   , arb_init   , arb_clear   , arb_midref+  , arb_radref   , _arb_vec_init   , _arb_vec_clear   , arb_swap@@ -396,6 +397,8 @@  -- Real numbers ---------------------------------------------------------------- +import System.IO.Unsafe+ import Foreign.Ptr import Foreign.ForeignPtr import Foreign.C.Types@@ -470,8 +473,15 @@   p_arb_clear :: FunPtr (Ptr CArb -> IO ())  foreign import ccall "arb.h arb_midref_"-  arb_midref :: Ptr CArb -> IO (Ptr CArf)-  +  arb_midref_ :: Ptr CArb -> IO (Ptr CArf)++arb_midref = unsafePerformIO . arb_midref_++foreign import ccall "arb.h arb_radref_"+  arb_radref_ :: Ptr CArb -> IO (Ptr CMag)++arb_radref = unsafePerformIO . arb_radref_+ -- | /_arb_vec_init/ /n/  --  -- Returns a pointer to an array of /n/ initialized @arb_struct@ entries.

@@ -24,6 +24,7 @@   , arb_fmpz_poly_deflate   -- * Polynomial roots   , arb_fmpz_poly_complex_roots+  , arb_fmpz_poly_roots_verbose   -- * Special polynomials   , arb_fmpz_poly_cos_minpoly   , arb_fmpz_poly_gauss_period_minpoly@@ -52,6 +53,15 @@ import Data.Number.Flint.Acb.Types import Data.Number.Flint.Acb.Poly +#include <flint/arb_fmpz_poly.h>++-- Flags -----------------------------------------------------------------------++type ArbFmpzPolyFlags = CInt++arb_fmpz_poly_roots_verbose :: ArbFmpzPolyFlags+arb_fmpz_poly_roots_verbose = #const ARB_FMPZ_POLY_ROOTS_VERBOSE+ -- Evaluation ------------------------------------------------------------------  -- | /_arb_fmpz_poly_evaluate_arb_horner/ /res/ /poly/ /len/ /x/ /prec/ @@ -174,7 +184,7 @@ --  -- The following /flags/ are supported: -- --- -   /ARB_FMPZ_POLY_ROOTS_VERBOSE/+-- -   /arb_fmpz_poly_roots_verbose/ foreign import ccall "arb_fmpz_poly.h arb_fmpz_poly_complex_roots"   arb_fmpz_poly_complex_roots :: Ptr CAcb -> Ptr CFmpzPoly -> CInt -> CLong -> IO () 

@@ -1,5 +1,6 @@-{-# OPTIONS_HADDOCK hide, prune, ignore-exports #-}-module Data.Number.Flint.Arb.Instances where+module Data.Number.Flint.Arb.Instances (+  Arb (..)+) where  import Test.QuickCheck @@ -7,6 +8,7 @@ import Foreign.C.String import Foreign.Marshal.Alloc ( free ) +import Data.Char import Data.Number.Flint.Arb  instance Show Arb where@@ -16,3 +18,4 @@     free cs     return s +  

@@ -55,6 +55,7 @@   , mag_min   , mag_max   -- * Input and output+  , mag_get_str   , mag_print   , mag_fprint   , mag_dump_str

@@ -0,0 +1,67 @@+module Data.Number.Flint.Arb.Mag.Instances (+  Mag (..)+) where++import System.IO.Unsafe+import Foreign.C.String+import Foreign.Marshal.Alloc++import Data.Number.Flint.Fmpz+import Data.Number.Flint.Fmpz.Instances+import Data.Number.Flint.Arb.Mag++instance Show Mag where+  show x = unsafePerformIO $ do+    (_, cs) <- withMag x mag_get_str+    s <- peekCString cs+    free cs+    return s++instance Eq Mag where+  (==) x y = snd $ snd $ unsafePerformIO $ do+    withMag x $ \x -> do+      withMag y $ \y -> do+        f <- mag_equal x y+        return $ f == 1++instance Ord Mag where+  compare x y = snd $ snd $ unsafePerformIO $ do+    withMag x $ \x -> do+      withMag y $ \y -> do+        f <- mag_cmp x y+        return $ f `compare` 0++instance Num Mag where+  (+) = lift2 mag_add+  (-) = lift2 mag_sub+  (*) = lift2 mag_mul+  abs = undefined+  signum = undefined+  fromInteger x = unsafePerformIO $ do+    let tmp = fromInteger x :: Fmpz+    result <- newMag+    withMag result $ \p -> do+      withFmpz tmp $ \tmp -> do+        mag_set_fmpz p tmp+    return result++instance Fractional Mag where+  (/) = lift2 mag_div+  recip = lift1 mag_inv+  fromRational = undefined+  +lift1 f x = fst $ unsafePerformIO $ +  withNewMag $ \result -> +    withMag x $ \x ->+      f result x+ +lift2 f x y = unsafePerformIO $ do+  result <- newMag+  withMag result $ \result -> do+    withMag x $ \x -> do+      withMag y $ \y -> do+        f result x y+  return result+++ 

@@ -1,4 +1,3 @@-{-# OPTIONS_HADDOCK hide, prune, ignore-exports #-} module Data.Number.Flint.Arb.Mat.Instances where  import System.IO.Unsafe

@@ -249,6 +249,7 @@   , _arb_poly_rising_ui_series   , arb_poly_rising_ui_series   -- * Zeta function+  , _arb_poly_zeta_series   , arb_poly_zeta_series   , _arb_poly_riemann_siegel_theta_series   , arb_poly_riemann_siegel_theta_series@@ -1823,6 +1824,12 @@   arb_poly_rising_ui_series :: Ptr CArbPoly -> Ptr CArbPoly -> CULong -> CLong -> CLong -> IO ()  -- Zeta function ---------------------------------------------------------------++-- | /_arb_poly_zeta_series/ /res/ /h/ /hlen/ /a/ /deflate/ /len/ /prec/+--+foreign import ccall "arb_poly.h _arb_poly_zeta_series"+  _arb_poly_zeta_series :: Ptr CArb -> Ptr CArb-> CLong -> Ptr CArb -> CInt+                        -> CLong -> CLong -> IO ()  -- | /arb_poly_zeta_series/ /res/ /s/ /a/ /deflate/ /n/ /prec/  --

@@ -1,4 +1,3 @@-{-# OPTIONS_HADDOCK hide, prune, ignore-exports #-} module Data.Number.Flint.Arb.Poly.Instances (     ArbPoly (..)   , module GHC.Exts

@@ -97,10 +97,9 @@     man <- newFmpz     exp <- newFmpz      withArb x $ \a -> do-      arf <- arb_midref a       withFmpz man $ \man -> do         withFmpz exp $ \exp -> do-          arf_get_fmpz_2exp man exp arf+          arf_get_fmpz_2exp man exp (arb_midref a)     return (toInteger man, fromIntegral exp)   encodeFloat man exp = unsafePerformIO $ do     let prec = fromInteger $ natVal (Proxy :: Proxy n)

@@ -1,4 +1,3 @@--- {-# OPTIONS_HADDOCK hide, prune, ignore-exports #-} module Data.Number.Flint.Arb.Types (   module Data.Number.Flint.Arb.Types.FFI   ) where

@@ -21,7 +21,10 @@ #include <flint/arf.h> #include <flint/mag.h> #include <flint/arb.h>+#include <flint/arb_calc.h> +-- mag_t -----------------------------------------------------------------------+ -- | Data structure containing the CMag pointer data Mag = Mag {-# UNPACK #-} !(ForeignPtr CMag) data CMag = CMag CFmpz CMpLimb@@ -107,32 +110,25 @@   poke = error "CArb.poke undefined."    -- | string options-newtype ArbStrOption = ArbStrOption {_ArbStrOption :: CULong}-  deriving (Show, Eq)+type ArbStrOption = CULong -instance Num ArbStrOption where-  (+) (ArbStrOption x) (ArbStrOption y) = ArbStrOption (x + y)-  (*) = undefined-  abs = undefined-  signum = undefined-  fromInteger = undefined-  negate = undefined+arb_str_none, arb_str_more, arb_str_no_radius, arb_str_condense :: ArbStrOption  -- | Default print option-arb_str_none      = ArbStrOption 0+arb_str_none      = 0 -- | If /arb_str_more/ is added to flags, more (possibly incorrect) -- digits may be printed-arb_str_more      = ArbStrOption #const ARB_STR_MORE+arb_str_more      = #const ARB_STR_MORE -- | If /arb_str_no_radius/ is added to /flags/, the radius is not -- included in the output if at least 1 digit of the midpoint can be -- printed.-arb_str_no_radius = ArbStrOption #const ARB_STR_NO_RADIUS+arb_str_no_radius = #const ARB_STR_NO_RADIUS -- | By adding a multiple m of /arb_str_condense/ to /flags/, strings of -- more than three times m consecutive digits are condensed, only -- printing the leading and trailing m digits along with brackets -- indicating the number of digits omitted (useful when computing -- values to extremely high precision).-arb_str_condense  = ArbStrOption #const ARB_STR_CONDENSE+arb_str_condense  = #const ARB_STR_CONDENSE  -- arb_poly_t ------------------------------------------------------------------ 

@@ -23,7 +23,9 @@   -- * Isolated Bernoulli numbers   , bernoulli_mod_p_harvey   , _bernoulli_fmpq_ui_zeta+  , _bernoulli_fmpq_ui_multi_mod   , _bernoulli_fmpq_ui+  , bernoulli_fmpq_ui ) where  -- Support for Bernoulli numbers -----------------------------------------------@@ -168,6 +170,9 @@ foreign import ccall "bernoulli.h _bernoulli_fmpq_ui_zeta"   _bernoulli_fmpq_ui_zeta :: Ptr CFmpz -> Ptr CFmpz -> CULong -> IO () +foreign import ccall "bernoulli.h  _bernoulli_fmpq_ui_multi_mod"+   _bernoulli_fmpq_ui_multi_mod :: Ptr CFmpz -> Ptr CFmpz -> CULong+                                -> CDouble -> IO ()  -- | /_bernoulli_fmpq_ui/ /num/ /den/ /n/  --  -- Computes the Bernoulli number \(B_n\) as an exact fraction, for an@@ -177,3 +182,5 @@ foreign import ccall "bernoulli.h _bernoulli_fmpq_ui"   _bernoulli_fmpq_ui :: Ptr CFmpz -> Ptr CFmpz -> CULong -> IO () +foreign import ccall "bernoulli.h bernoulli_fmpq_ui"+  bernoulli_fmpq_ui :: Ptr CFmpq -> CULong -> IO ()

@@ -0,0 +1,17 @@+{-|+module      :  Data.Number.Flint.Calcium+copyright   :  (c) 2023 Hartmut Monien+license     :  GNU GPL, version 2 or above (see LICENSE)+maintainer  :  hmonien@uni-bonn.de++Here we collect various utility methods for Flint, Arb and Antic types+that are missing in those libraries. Some of these functions may be+migrated upstream in the future.+-}++module Data.Number.Flint.Calcium (+  module Data.Number.Flint.Calcium.FFI+) where++import Data.Number.Flint.Calcium.FFI+

@@ -0,0 +1,82 @@+{-|+module      :  Data.Number.Flint.Calcium.Ca+copyright   :  (c) 2023 Hartmut Monien+license     :  GNU GPL, version 2 or above (see LICENSE)+maintainer  :  hmonien@uni-bonn.de++== Exact real and complex numbers++A @Ca@ represents a real or complex number in a form suitable for+exact field arithmetic or comparison. Exceptionally, a @Ca@ may+represent a special nonnumerical value, such as an infinity.++== Introduction: numbers ++A /Calcium number/ is a real or complex number represented as an element+of a formal field \(K = \mathbb{Q}(a_1, \ldots, a_n)\) where the +symbols \(a_k\) denote fixed algebraic or transcendental numbers called+/extension numbers/. For example, \(e^{\,- 2 \pi} - 3i\) may be+represented as \((1 - 3 a_2^2 a_1) / a_2^2\) in the+field \(\mathbb{Q}(a_1,a_2)\) with \(a_1 = i, a_2 = e^{\pi}\). +Extension numbers+and fields are documented in the following separate modules:++The user does not need to construct extension numbers or formal+extension fields explicitly: each @Ca@ contains an internal pointer to+its formal field, and operations on Calcium numbers generate and cache+fields automatically as needed to express the results.++This representation is not canonical (in general). A given complex+number can be represented in different ways depending on the choice of+formal field /K/. Even within a fixed field /K/, a number can have+different representations if there are algebraic relations between the+extension numbers. Two numbers /x/ and /y/ can be tested for inequality+using numerical evaluation; to test for equality, it may be necessary to+eliminate dependencies between extension numbers. One of the central+goals of Calcium will be to implement heuristics for such elimination.++Together with each formal field /K/, Calcium stores a /reduction ideal/+ \(I = \{g_1,\ldots,g_m\}\) with \(g_i \in \mathbb{Z}[a_1,\ldots,a_n]\),+defining a set of algebraic relations \( g_i(a_1,\ldots,a_n) = 0\). Relations+can be absolute, say \(g_i = a_j^2 + 1\), or relative, say+ \(g_i = 2 a_j - 4 a_k - a_l a_m\). The reduction ideal effectively+partitions \(K\) into equivalence classes of complex numbers (e.g.+ \(i^2 = -1\) or \(2 \log(\pi i) = 4 \log(\sqrt{\pi}) + \pi i\)),+enabling simplifications and equality proving.++Extension numbers are always sorted+ \(a_1 \succ a_2 \succ \ldots \succ a_n\) where \(\succ\) denotes a+structural ordering (see @ca_cmp_repr@). If the reduction ideal is+triangular and the multivariate polynomial arithmetic uses lexicographic+ordering, reduction by /I/ eliminates numbers \(a_i\) with higher+complexity in the sense of \(\succ\).++The reduction ideal is an imperfect computational crutch: it is not+guaranteed to capture /all/ algebraic relations, and reduction is not+guaranteed to produce uniquely defined representatives. However, in the+specific case of an absolute number field \(K = \mathbb{Q}(a)\) where+/a/ is a @qqbar_t@ extension, the reduction ideal (consisting of a+single minimal polynomial) is canonical and field elements of /K/ can be+chosen canonically.++== Introduction: special values++In order to provide a closed arithmetic system and express limiting+cases of operators and special functions, a @Ca@ can hold any of the+following special values besides ordinary numbers:++The distinction between /Calcium numbers/ (which must represent elements+of \(\mathbb{C}\)) and the different kinds of nonnumerical values+(infinities, Undefined or Unknown) is essential. Nonnumerical values may+not be used as field extension numbers \(a_k\), and the denominator of a+formal field element must always represent a nonzero complex number.+Accordingly, for any given Calcium value /x/ that is not /Unknown/, it+is exactly known whether /x/ represents A) a number, B) unsigned+infinity, C) a signed infinity, or D) Undefined.+-}+module Data.Number.Flint.Calcium.Ca (+  module Data.Number.Flint.Calcium.Ca.FFI+  ) where+  +import GHC.Exts+import Data.Number.Flint.Calcium.Ca.FFI

@@ -0,0 +1,33 @@+{-|+module      :  Data.Number.Flint.Calcium.Ca.Ext+copyright   :  (c) 2023 Hartmut Monien+license     :  GNU GPL, version 2 or above (see LICENSE)+maintainer  :  hmonien@uni-bonn.de+++A @CaExt@ represents a fixed real or complex number /a/.++The @CaExt@ structure is heavy-weight object, not just meant to act+as a node in a symbolic expression. It will cache various data to+support repeated computation with this particular number, including its+numerical enclosure and number field data in the case of algebraic+numbers.++Extension numbers are used internally by the @Ca@ type to define the+embeddings \(\mathbb{Q}(a) \to \mathbb{C}\) of formal fields. The user+does not normally need to create @ca_ext_t@ instances directly; the+intended way for the user to work with the extension number /a/ is to+create a @ca_t@ representing the field element \(1 \cdot a\). The+underlying @CaExt@ may be accessed to determine symbolic and+numerical properties of this number.++Since extension numbers may depend recursively on nontrivial fields for+function arguments, @CaExt@ operations require a @CaCtx@ context+object.++-}+module Data.Number.Flint.Calcium.Ca.Ext (+  module Data.Number.Flint.Calcium.Ca.Ext.FFI+  ) where+  +import Data.Number.Flint.Calcium.Ca.Ext.FFI

@@ -0,0 +1,262 @@+module Data.Number.Flint.Calcium.Ca.Ext.FFI (+  -- * Real and complex extension numbers+  -- * Type and macros+    CaExt (..)+  , CCaExt (..)+  , newCaExtQQbar+  , newCaExtConst+  , newCaExtFx+  , newCaExtFxy+  , newCaExtFxn+  , withCaExt+  -- * Memory management+  , ca_ext_init_qqbar+  , ca_ext_init_const+  , ca_ext_init_fx+  , ca_ext_init_fxy+  , ca_ext_init_fxn+  , ca_ext_init_set+  , ca_ext_clear+  -- * Structure+  , ca_ext_nargs+  , ca_ext_get_arg+  , ca_ext_hash+  , ca_ext_equal_repr+  , ca_ext_cmp_repr+  -- * Input and output+  , ca_ext_print+  -- * Numerical evaluation+  , ca_ext_get_acb_raw+  -- * Cache+  , ca_ext_cache_init+  , ca_ext_cache_clear+  , ca_ext_cache_insert+) where ++-- Real and complex extension numbers ------------------------------------------++import Foreign.Ptr+import Foreign.ForeignPtr+import Foreign.C.Types+import Foreign.C.String+import Foreign.Storable+import Foreign.Marshal.Array++import Data.Number.Flint.Flint+import Data.Number.Flint.Fmpz+import Data.Number.Flint.Acb.Types+import Data.Number.Flint.NF.QQbar+import Data.Number.Flint.Calcium+import Data.Number.Flint.Calcium.Ca+import Data.Number.Flint.Calcium.Ca.Types++#include <flint/ca_ext.h>++-- ca_ext_t --------------------------------------------------------------------++instance Storable CCaExt where+  {-# INLINE sizeOf #-}+  sizeOf _ = #{size ca_ext_t}+  {-# INLINE alignment #-}+  alignment _ = #{alignment ca_ext_t}+  peek = error "CCaExt.peek: Not defined"+  poke = error "CCaExt.poke: Not defined"++newCaExtQQbar x ctx@(CaCtx ctxf) = do+  res <- mallocForeignPtr+  withForeignPtr res $ \resp -> do+    withCaCtx ctx $ \ctxp -> do+      withQQbar x $ \xp -> do+        ca_ext_init_qqbar resp xp ctxp+    addForeignPtrFinalizerEnv p_ca_ext_clear resp ctxf+  return $ CaExt res++newCaExtConst fc ctx@(CaCtx ctxf) = do+  res <- mallocForeignPtr+  withForeignPtr res $ \resp -> do+    withCaCtx ctx $ \ctxp -> do+      ca_ext_init_const resp fc ctxp+    addForeignPtrFinalizerEnv p_ca_ext_clear resp ctxf+  return $ CaExt res++newCaExtFx fx x ctx@(CaCtx ctxf) = do+  res <- mallocForeignPtr+  withForeignPtr res $ \resp -> do+    withCaCtx ctx $ \ctxp -> do+      withCa x $ \x -> do+        ca_ext_init_fx resp fx x ctxp+    addForeignPtrFinalizerEnv p_ca_ext_clear resp ctxf+  return $ CaExt res++newCaExtFxy fxy x y ctx@(CaCtx ctxf) = do+  res <- mallocForeignPtr+  withForeignPtr res $ \resp -> do+    withCaCtx ctx $ \ctxp -> do+      withCa x $ \x -> do+        withCa y $ \y -> do+          ca_ext_init_fxy resp fxy x y ctxp+    addForeignPtrFinalizerEnv p_ca_ext_clear resp ctxf+  return $ CaExt res++newCaExtFxn fxn x nargs ctx@(CaCtx ctxf) = do+  res <- mallocForeignPtr+  withForeignPtr res $ \resp -> do+    withCaCtx ctx $ \ctxp -> do+      withCa x $ \x -> do+        ca_ext_init_fxn resp fxn x nargs ctxp+    addForeignPtrFinalizerEnv p_ca_ext_clear resp ctxf+  return $ CaExt res++withCaExt (CaExt x) f = do+  withForeignPtr x $ \px -> f px >>= return . (CaExt x,)++-- Memory management -----------------------------------------------------------++-- | /ca_ext_init_qqbar/ /res/ /x/ /ctx/ +--+-- Initializes /res/ and sets it to the algebraic constant /x/.+foreign import ccall "ca_ext.h ca_ext_init_qqbar"+  ca_ext_init_qqbar :: Ptr CCaExt -> Ptr CQQbar -> Ptr CCaCtx -> IO ()++-- | /ca_ext_init_const/ /res/ /func/ /ctx/ +--+-- Initializes /res/ and sets it to the constant defined by /func/+-- (example: /func/ = /CA_Pi/ for \(x = \pi\)).+foreign import ccall "ca_ext.h ca_ext_init_const"+  ca_ext_init_const :: Ptr CCaExt -> CCalciumFunctionCode -> Ptr CCaCtx -> IO ()++-- | /ca_ext_init_fx/ /res/ /func/ /x/ /ctx/ +--+-- Initializes /res/ and sets it to the univariate function value \(f(x)\)+-- where /f/ is defined by /func/ (example: /func/ = /CA_Exp/ for \(e^x\)).+foreign import ccall "ca_ext.h ca_ext_init_fx"+  ca_ext_init_fx :: Ptr CCaExt -> CCalciumFunctionCode -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_ext_init_fxy/ /res/ /func/ /x/ /y/ /ctx/ +--+-- Initializes /res/ and sets it to the bivariate function value+-- \(f(x, y)\) where /f/ is defined by /func/ (example: /func/ = /CA_Pow/+-- for \(x^y\)).+foreign import ccall "ca_ext.h ca_ext_init_fxy"+  ca_ext_init_fxy :: Ptr CCaExt -> CCalciumFunctionCode -> Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_ext_init_fxn/ /res/ /func/ /x/ /nargs/ /ctx/ +--+-- Initializes /res/ and sets it to the multivariate function value+-- \(f(x_1, \ldots, x_n)\) where /f/ is defined by /func/ and /n/ is given+-- by /nargs/.+foreign import ccall "ca_ext.h ca_ext_init_fxn"+  ca_ext_init_fxn :: Ptr CCaExt -> CCalciumFunctionCode -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_ext_init_set/ /res/ /x/ /ctx/ +--+-- Initializes /res/ and sets it to a copy of /x/.+foreign import ccall "ca_ext.h ca_ext_init_set"+  ca_ext_init_set :: Ptr CCaExt -> Ptr CCaExt -> Ptr CCaCtx -> IO ()++-- | /ca_ext_clear/ /res/ /ctx/ +--+-- Clears /res/.+foreign import ccall "ca_ext.h ca_ext_clear"+  ca_ext_clear :: Ptr CCaExt -> Ptr CCaCtx -> IO ()++foreign import ccall "ca_ext.h &ca_ext_clear"+  p_ca_ext_clear :: FunPtr (Ptr CCaExt -> Ptr CCaCtx -> IO ())++-- Structure -------------------------------------------------------------------++-- | /ca_ext_nargs/ /x/ /ctx/ +--+-- Returns the number of function arguments of /x/. The return value is 0+-- for any algebraic constant and for any built-in symbolic constant such+-- as \(\pi\).+foreign import ccall "ca_ext.h ca_ext_nargs"+  ca_ext_nargs :: Ptr CCaExt -> Ptr CCaCtx -> IO CLong++-- | /ca_ext_get_arg/ /res/ /x/ /i/ /ctx/ +--+-- Sets /res/ to argument /i/ (indexed from zero) of /x/. This calls+-- /flint_abort/ if /i/ is out of range.+foreign import ccall "ca_ext.h ca_ext_get_arg"+  ca_ext_get_arg :: Ptr CCa -> Ptr CCaExt -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_ext_hash/ /x/ /ctx/ +--+-- Returns a hash of the structural representation of /x/.+foreign import ccall "ca_ext.h ca_ext_hash"+  ca_ext_hash :: Ptr CCaExt -> Ptr CCaCtx -> IO CULong++-- | /ca_ext_equal_repr/ /x/ /y/ /ctx/ +--+-- Tests /x/ and /y/ for structural equality, returning 0 (false) or 1+-- (true).+foreign import ccall "ca_ext.h ca_ext_equal_repr"+  ca_ext_equal_repr :: Ptr CCaExt -> Ptr CCaExt -> Ptr CCaCtx -> IO CInt++-- | /ca_ext_cmp_repr/ /x/ /y/ /ctx/ +--+-- Compares the representations of /x/ and /y/ in a canonical sort order,+-- returning -1, 0 or 1. This only performs a structural comparison of the+-- symbolic representations; the return value does not say anything+-- meaningful about the numbers represented by /x/ and /y/.+foreign import ccall "ca_ext.h ca_ext_cmp_repr"+  ca_ext_cmp_repr :: Ptr CCaExt -> Ptr CCaExt -> Ptr CCaCtx -> IO CInt++-- Input and output ------------------------------------------------------------++foreign import ccall "ca_ext.h ca_ext_get_str"+  ca_ext_get_str :: Ptr CCaExt -> Ptr CCaCtx -> IO CString++foreign import ccall "ca_ext.h ca_ext_fprint"+  ca_ext_fprint :: Ptr CFile -> Ptr CCaExt -> Ptr CCaCtx -> IO ()++-- | /ca_ext_print/ /x/ /ctx/ +--+-- Prints a description of /x/ to standard output.+ca_ext_print :: Ptr CCaExt -> Ptr CCaCtx -> IO ()+ca_ext_print x ctx = do+  printCStr (flip ca_ext_get_str ctx) x+  return ()++-- Numerical evaluation --------------------------------------------------------++-- | /ca_ext_get_acb_raw/ /res/ /x/ /prec/ /ctx/ +--+-- Sets /res/ to an enclosure of the numerical value of /x/. A working+-- precision of /prec/ bits is used for the evaluation, without adaptive+-- refinement.+foreign import ccall "ca_ext.h ca_ext_get_acb_raw"+  ca_ext_get_acb_raw :: Ptr CAcb -> Ptr CCaExt -> CLong -> Ptr CCaCtx -> IO ()++-- Cache -----------------------------------------------------------------------++++++++-- | /ca_ext_cache_init/ /cache/ /ctx/ +--+-- Initializes /cache/ for use.+foreign import ccall "ca_ext.h ca_ext_cache_init"+  ca_ext_cache_init :: Ptr CCaExtCache -> Ptr CCaCtx -> IO ()++-- | /ca_ext_cache_clear/ /cache/ /ctx/ +--+-- Clears /cache/, freeing the memory allocated internally.+foreign import ccall "ca_ext.h ca_ext_cache_clear"+  ca_ext_cache_clear :: Ptr CCaExtCache -> Ptr CCaCtx -> IO ()++-- | /ca_ext_cache_insert/ /cache/ /x/ /ctx/ +--+-- Adds /x/ to /cache/ without duplication. If a structurally identical+-- instance already exists in /cache/, a pointer to that instance is+-- returned. Otherwise, a copy of /x/ is inserted into /cache/ and a+-- pointer to that new instance is returned.+foreign import ccall "ca_ext.h ca_ext_cache_insert"+  ca_ext_cache_insert :: Ptr CCaExtCache -> Ptr CCaExt -> Ptr CCaCtx -> IO (Ptr CCaExt)++++

@@ -0,0 +1,2106 @@+{-| +module      :  Data.Number.Flint.Calcium.Ca.FFI+copyright   :  (c) 2022 Hartmut Monien+license     :  GNU GPL, version 2 or above (see LICENSE)+maintainer  :  hmonien@uni-bonn.de+-}+module Data.Number.Flint.Calcium.Ca.FFI (+  -- * Exact Numbers+    Ca (..)+  , CCa (..)+  , CaCtx (..)+  , CCaCtx (..)+  , newCa+  , withCa+  , withNewCa+  , newCaCtx+  , withCaCtx+  -- * Number objects+  -- * Context objects+  , ca_ctx_init+  , ca_ctx_clear+  , ca_ctx_print+  , ca_ctx_get_option+  , ca_ctx_set_option+  -- * Memory management for numbers+  , ca_init+  , ca_clear+  , ca_swap+  -- * Symbolic expressions+  , ca_get_fexpr+  , ca_set_fexpr+  -- * Print flags+  , CalciumPrintOption (..)+  -- +  -- | The style of printed output is controlled a flag which can be+  --   set to any combination of the following flags:+  , ca_print_n+  , ca_print_repr+  , ca_print_field+  , ca_print_digits+  , ca_print_default+  , ca_print_debug+  -- $printflags+  +  -- * Print+  , ca_print+  , ca_fprint+  , ca_get_str+  , ca_printn+  -- * Special values+  , ca_zero+  , ca_one+  , ca_neg_one+  , ca_i+  , ca_neg_i+  , ca_pi+  , ca_pi_i+  , ca_euler+  , ca_unknown+  , ca_undefined+  , ca_uinf+  , ca_pos_inf+  , ca_neg_inf+  , ca_pos_i_inf+  , ca_neg_i_inf+  -- * Assignment and conversion+  , ca_set+  , ca_set_si+  , ca_set_ui+  , ca_set_fmpz+  , ca_set_fmpq+  , ca_set_d+  , ca_set_d_d+  , ca_transfer+  -- * Conversion of algebraic numbers+  , ca_set_qqbar+  , ca_get_fmpz+  , ca_get_fmpq+  , ca_get_qqbar+  , ca_can_evaluate_qqbar+  -- * Random generation+  , ca_randtest_rational+  , ca_randtest+  , ca_randtest_special+  , ca_randtest_same_nf+  -- * Representation properties+  -- $representation+  , ca_equal_repr+  , ca_cmp_repr+  , ca_hash_repr+  , ca_is_unknown+  , ca_is_special+  , ca_is_qq_elem+  , ca_is_qq_elem_zero+  , ca_is_qq_elem_one+  , ca_is_qq_elem_integer+  , ca_is_nf_elem+  , ca_is_cyclotomic_nf_elem+  , ca_is_generic_elem+  -- * Value predicates+  , ca_check_is_number+  , ca_check_is_zero+  , ca_check_is_one+  , ca_check_is_neg_one+  , ca_check_is_i+  , ca_check_is_neg_i+  , ca_check_is_algebraic+  , ca_check_is_rational+  , ca_check_is_integer+  , ca_check_is_real+  , ca_check_is_negative_real+  , ca_check_is_imaginary+  , ca_check_is_undefined+  , ca_check_is_infinity+  , ca_check_is_uinf+  , ca_check_is_signed_inf+  , ca_check_is_pos_inf+  , ca_check_is_neg_inf+  , ca_check_is_pos_i_inf+  , ca_check_is_neg_i_inf+  -- * Comparisons+  , ca_check_equal+  , ca_check_lt+  , ca_check_le+  , ca_check_gt+  , ca_check_ge+  -- * Field structure operations+  , ca_merge_fields+  , ca_condense_field+  , ca_is_gen_as_ext+  -- * Arithmetic+  , ca_neg+  , ca_add_fmpq+  , ca_add_fmpz+  , ca_add_ui+  , ca_add_si+  , ca_add+  , ca_sub_fmpq+  , ca_sub_fmpz+  , ca_sub_ui+  , ca_sub_si+  , ca_fmpq_sub+  , ca_fmpz_sub+  , ca_ui_sub+  , ca_si_sub+  , ca_sub+  , ca_mul_fmpq+  , ca_mul_fmpz+  , ca_mul_ui+  , ca_mul_si+  , ca_mul+  , ca_inv+  , ca_fmpq_div+  , ca_fmpz_div+  , ca_ui_div+  , ca_si_div+  , ca_div_fmpq+  , ca_div_fmpz+  , ca_div_ui+  , ca_div_si+  , ca_div+  , ca_dot+  , ca_fmpz_poly_evaluate+  , ca_fmpq_poly_evaluate+  , ca_fmpz_mpoly_evaluate_horner+--, ca_fmpz_mpoly_evaluate_iter+  , ca_fmpz_mpoly_evaluate+  , ca_fmpz_mpoly_q_evaluate+  , ca_fmpz_mpoly_q_evaluate_no_division_by_zero+  , ca_inv_no_division_by_zero+  -- * Powers and roots+  , ca_sqr+  , ca_pow_fmpq+  , ca_pow_fmpz+  , ca_pow_ui+  , ca_pow_si+  , ca_pow+  , ca_pow_si_arithmetic+  , ca_sqrt_inert+  , ca_sqrt_nofactor+  , ca_sqrt_factor+  , ca_sqrt+  , ca_sqrt_ui+  -- * Complex parts+  , ca_abs+  , ca_sgn+  , ca_csgn+  , ca_arg+  , ca_re+  , ca_im+  , ca_conj_deep+  , ca_conj_shallow+  , ca_conj+  , ca_floor+  , ca_ceil+  -- * Exponentials and logarithms+  , ca_exp+  , ca_log+  -- * Trigonometric functions+  , ca_sin_cos_exponential+  , ca_sin_cos_direct+  , ca_sin_cos_tangent+  , ca_sin_cos+  , ca_sin+  , ca_cos+  , ca_tan_sine_cosine+  , ca_tan_exponential+  , ca_tan_direct+  , ca_tan+  , ca_cot+  , ca_atan_logarithm+  , ca_atan_direct+  , ca_atan+  , ca_asin_logarithm+  , ca_acos_logarithm+  , ca_asin_direct+  , ca_acos_direct+  , ca_asin+  , ca_acos+  -- * Special functions+  , ca_gamma+  , ca_erf+  , ca_erfc+  , ca_erfi+  -- * Numerical evaluation+  , ca_get_acb_raw+  , ca_get_acb+  , ca_get_acb_accurate_parts+  , ca_get_decimal_str+  -- * Rewriting and simplification+  , ca_rewrite_complex_normal_form+  -- * Factorization+  , CaFactor (..)+  , CCaFactor (..)+  , newCaFactor+  , withCaFactor+  , ca_factor_init+  , ca_factor_clear+  , ca_factor_one+  , ca_factor_print+  , ca_factor_insert+  , ca_factor_get_ca+  , ca_factor+  -- * Factorization options+  --+  -- $factorization_options+  +  , ca_factor_poly_none+  , ca_factor_poly_content+  , ca_factor_poly_sqf+  , ca_factor_poly_full+  , ca_factor_zz_none+  , ca_factor_zz_smooth+  , ca_factor_zz_full+  -- * Context options+  --+  -- $context_options+  +  , ca_opt_verbose+  , ca_opt_print_flags+  , ca_opt_mpoly_ord+  , ca_opt_prec_limit+  , ca_opt_qqbar_deg_limit+  , ca_opt_low_prec+  , ca_opt_smooth_limit+  , ca_opt_lll_prec+  , ca_opt_pow_limit+  , ca_opt_use_groebner+  , ca_opt_groebner_length_limit+  , ca_opt_groebner_poly_length_limit+  , ca_opt_groebner_poly_bits_limit+  , ca_opt_vieta_limit+  , ca_opt_trig_form+  , ca_trig_direct+  , ca_trig_exponential+  , ca_trig_sine_cosine+  , ca_trig_tangent+  -- * Internal representation+  , _ca_make_field_element+  , _ca_make_fmpq+) where++-- Exact real and complex numbers ----------------------------------------------++import Foreign.Ptr+import Foreign.ForeignPtr+import Foreign.Storable+import Foreign.C.Types+import Foreign.C.String++import Data.Number.Flint.Flint++import Data.Number.Flint.Fmpz+import Data.Number.Flint.Fmpz.Poly+import Data.Number.Flint.Fmpz.MPoly+import Data.Number.Flint.Fmpz.MPoly.Q+import Data.Number.Flint.Fmpq+import Data.Number.Flint.Fmpq.Poly++import Data.Number.Flint.NF.QQbar++import Data.Number.Flint.Arb.Types+import Data.Number.Flint.Acb.Types++import Data.Number.Flint.Calcium+import Data.Number.Flint.Calcium.Ca.Types++#include <flint/ca.h>++-- ca_t ------------------------------------------------------------------------++instance Storable CCa where+  {-# INLINE sizeOf #-}+  sizeOf _ = #{size ca_t}+  {-# INLINE alignment #-}+  alignment _ = #{alignment ca_t}+  peek = error "CCa.peek: Not defined"+  poke = error "CCa.poke: Not defined"++newCa ctx@(CaCtx fctx) = do+  x <- mallocForeignPtr+  withForeignPtr x $ \xp -> do+    withCaCtx ctx $ \ctxp -> do+      ca_init xp ctxp+    addForeignPtrFinalizerEnv p_ca_clear xp fctx+  return $ Ca x++{-# INLINE withCa #-}+withCa (Ca x) f = do+  withForeignPtr x $ \xp -> f xp >>= return . (Ca x,)++withNewCa ctx f = do+  x <- newCa ctx+  withCa x f+  +-- ca_factor -------------------------------------------------------------------++instance Storable CCaFactor where+  {-# INLINE sizeOf #-}+  sizeOf _ = #{size ca_factor_t}+  {-# INLINE alignment #-}+  alignment _ = #{alignment ca_factor_t}+  peek = error "CCaFactor.peek: Not defined"+  poke = error "CCaFactor.poke: Not defined"++newCaFactor ctx@(CaCtx fctx) = do+  x <- mallocForeignPtr+  withForeignPtr x $ \xp -> do+    withCaCtx ctx $ \ctxp -> do+      ca_factor_init xp ctxp+    addForeignPtrFinalizerEnv p_ca_factor_clear xp fctx+  return $ CaFactor x++{-# INLINE withCaFactor #-}+withCaFactor (CaFactor x) f = do+  withForeignPtr x $ \xp -> f xp >>= return . (CaFactor x,)++withNewCaFactor ctx f = do+  x <- newCaFactor ctx+  withCaCtx ctx $ \ctx -> do+    withCaFactor x $ \x -> do+      f x ctx+    +-- ca_ctx ----------------------------------------------------------------------++instance Storable CCaCtx where+  {-# INLINE sizeOf #-}+  sizeOf _ = #{size ca_ctx_t}+  {-# INLINE alignment #-}+  alignment _ = #{alignment ca_ctx_t}+  peek = error "CCaCtx.peek: Not defined"+  poke = error "CCaCtx.poke: Not defined"++newCaCtx = do+  ctx <- mallocForeignPtr+  withForeignPtr ctx $ \ctxp -> do+    ca_ctx_init ctxp+  addForeignPtrFinalizer p_ca_ctx_clear ctx+  return $ CaCtx ctx++withCaCtx (CaCtx x) f = do+  withForeignPtr x $ \xp -> f xp >>= return . (CaCtx x,)+  +--------------------------------------------------------------------------------++-- | /ca_ctx_init/ /ctx/ +--+-- Initializes the context object /ctx/ for use. Any evaluation options+-- stored in the context object are set to default values.+foreign import ccall "ca.h ca_ctx_init"+  ca_ctx_init :: Ptr CCaCtx -> IO ()++-- | /ca_ctx_clear/ /ctx/ +--+-- Clears the context object /ctx/, freeing any memory allocated+-- internally. This function should only be called after all @ca_t@+-- instances referring to this context have been cleared.+foreign import ccall "ca.h ca_ctx_clear"+  ca_ctx_clear :: Ptr CCaCtx -> IO ()++foreign import ccall "ca.h &ca_ctx_clear"+  p_ca_ctx_clear :: FunPtr (Ptr CCaCtx -> IO ())++-- | /ca_ctx_print/ /ctx/ +--+-- Prints a description of the context /ctx/ to standard output. This will+-- give a complete listing of the cached fields in /ctx/.+foreign import ccall "ca.h ca_ctx_print"+  ca_ctx_print :: Ptr CCaCtx -> IO ()++-- | /ca_ctx_get_options/ /ctx/ /i/+foreign import ccall "ca.h ca_ctx_get_option"+  ca_ctx_get_option :: Ptr CCaCtx -> CLong -> IO ()++-- | /ca_ctx_set_option/ /ctx/ /i/ /value/+foreign import ccall "ca.h ca_ctx_set_option"+  ca_ctx_set_option :: Ptr CCaCtx -> CLong -> CLong -> IO ()+  +-- Memory management for numbers -----------------------------------------------++-- | /ca_init/ /x/ /ctx/ +--+-- Initializes the variable /x/ for use, associating it with the context+-- object /ctx/. The value of /x/ is set to the rational number 0.+foreign import ccall "ca.h ca_init"+  ca_init :: Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_clear/ /x/ /ctx/ +--+-- Clears the variable /x/.+foreign import ccall "ca.h ca_clear"+  ca_clear :: Ptr CCa -> Ptr CCaCtx -> IO ()++foreign import ccall "ca.h &ca_clear"+  p_ca_clear :: FunPtr (Ptr CCa -> Ptr CCaCtx -> IO ())++-- | /ca_swap/ /x/ /y/ /ctx/ +--+-- Efficiently swaps the variables /x/ and /y/.+foreign import ccall "ca.h ca_swap"+  ca_swap :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- Symbolic expressions --------------------------------------------------------++-- | /ca_get_fexpr/ /res/ /x/ /flags/ /ctx/ +--+-- Sets /res/ to a symbolic expression representing /x/.+foreign import ccall "ca.h ca_get_fexpr"+  ca_get_fexpr :: Ptr CFexpr -> Ptr CCa -> CULong -> Ptr CCaCtx -> IO ()++-- | /ca_set_fexpr/ /res/ /expr/ /ctx/ +--+-- Sets /res/ to the value represented by the symbolic expression /expr/.+-- Returns 1 on success and 0 on failure. This function essentially just+-- traverses the expression tree using @ca@ arithmetic; it does not provide+-- advanced symbolic evaluation. It is guaranteed to at least be able to+-- parse the output of @ca_get_fexpr@.+foreign import ccall "ca.h ca_set_fexpr"+  ca_set_fexpr :: Ptr CCa -> Ptr CFexpr -> Ptr CCaCtx -> IO CInt++-- Printing --------------------------------------------------------------------++type CalciumPrintOption = CULong++ca_print_n, ca_print_digits, ca_print_repr, ca_print_field, ca_print_default, ca_print_debug :: CalciumPrintOption++-- | /ca_print_n/+--+-- Print a decimal approximation of the number.+-- The approximation is guaranteed to be correctly rounded to within+-- one unit in the last place.+-- +-- If combined with ``ca_print_repr``, numbers appearing+-- within the symbolic representation will also be printed with+-- decimal approximations.+--+-- Warning: printing a decimal approximation requires a computation,+-- which can be expensive. It can also mutate+-- cached data (numerical enclosures of extension numbers), affecting+-- subsequent computations.+ca_print_n       =  #const CA_PRINT_N +-- | /ca_print_digits/+--+-- Multiplied by a positive integer, specifies the number of+-- decimal digits to show with ``ca_print_n``. If not given,+-- the default precision is six digits.+ca_print_digits  = #const CA_PRINT_DIGITS+-- | /ca_print_repr/+--+-- Print the symbolic representation of the number (including+-- its recursive elements). If used together with ``ca_print_n``,+-- field elements will print as ``decimal {symbolic}`` while+-- extension numbers will print as ``decimal [symbolic]``.+--+-- All extension numbers appearing in the field defining ``x``+-- and in the inner constructions of those extension numbers+-- will be given local labels ``a``, ``b``, etc. for this printing.+ca_print_repr    = #const CA_PRINT_REPR+-- | /ca_print_field/+--+-- For each field element, explicitly print its formal field+-- along with its reduction ideal if present, e.g. ``QQ`` or+-- ``QQ(a,b,c) / <a-b, c^2+1>``.+ca_print_field   = #const CA_PRINT_FIELD+-- | /ca_print_default/+--+-- The default print style. Equivalent to ``ca_print_n | ca_print_repr``.+ca_print_default = #const CA_PRINT_DEFAULT+-- | /ca_print_debug/+--+-- Verbose print style for debugging. Equivalent to ``ca_print_n |+-- ca_print_repr | ca_print_field``.+ca_print_debug   = #const CA_PRINT_DEBUG++-- $printflags+--+-- == Example for print flags+-- +-- As a special case, small integers are always printed as simple literals.+--+-- As illustration, here are the numbers -7, \(2/3\), \((\sqrt{3}+5)/2\)+-- and \(\sqrt{2} (\log(\pi) + \pi i)\) printed in various styles:+--+-- >> ca_print_default+-- -7+-- 0.666667 {2/3}+-- 3.36603 {(a+5)/2 where a = 1.73205 [a^2-3=0]}+-- 1.61889 + 4.44288*I {a*c+b*c*d where a = 1.14473 [Log(3.14159 {b})], b = 3.14159 [Pi], c = 1.41421 [c^2-2=0], d = I [d^2+1=0]}+--+-- >> ca_print_n+-- -7+-- 0.666667+-- 3.36603+-- 1.61889 + 4.44288*I+--+-- >> ca_print_n .|. (ca_print_digits * 20)+-- -7+-- 0.66666666666666666667+-- 3.3660254037844386468+-- 1.6188925298220266685 + 4.4428829381583662470*I+--+-- >> ca_print_repr+-- -7+-- 2/3+-- (a+5)/2 where a = [a^2-3=0]+-- a*c+b*c*d where a = Log(b), b = Pi, c = [c^2-2=0], d = [d^2+1=0]+--+-- >> ca_print_debug+-- -7+-- 0.666667 {2/3  in  QQ}+-- 3.36603 {(a+5)/2  in  QQ(a)/<a^2-3> where a = 1.73205 [a^2-3=0]}+-- 1.61889 + 4.44288*I {a*c+b*c*d  in  QQ(a,b,c,d)/<c^2-2, d^2+1> where a = 1.14473 [Log(3.14159 {b  in  QQ(b)})], b = 3.14159 [Pi], c = 1.41421 [c^2-2=0], d = I [d^2+1=0]}++-- | /ca_print/ /x/ /ctx/ +--+-- Prints /x/ to standard output.+ca_print :: Ptr CCa -> Ptr CCaCtx -> IO ()+ca_print x ctx = do+  printCStr (\x -> ca_get_str x ctx) x+  return ()+  +-- | /ca_fprint/ /fp/ /x/ /ctx/ +--+-- Prints /x/ to the file /fp/.+foreign import ccall "ca.h ca_fprint"+  ca_fprint :: Ptr CFile -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_get_str/ /x/ /ctx/ +--+-- Prints /x/ to a string which is returned. The user should free this+-- string by calling @flint_free@.+foreign import ccall "ca.h ca_get_str"+  ca_get_str :: Ptr CCa -> Ptr CCaCtx -> IO CString++-- | /ca_printn/ /x/ /n/ /ctx/ +--+-- Prints an /n/-digit numerical representation of /x/ to standard output.+foreign import ccall "ca.h ca_printn"+  ca_printn :: Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()++-- Special values --------------------------------------------------------------++-- | /ca_zero/ /res/ /ctx/ +foreign import ccall "ca.h ca_zero"+  ca_zero :: Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_one/ /res/ /ctx/ +foreign import ccall "ca.h ca_one"+  ca_one :: Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_neg_one/ /res/ /ctx/ +--+-- Sets /res/ to the integer 0, 1 or -1. This creates a canonical+-- representation of this number as an element of the trivial field+-- \(\mathbb{Q}\).+foreign import ccall "ca.h ca_neg_one"+  ca_neg_one :: Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_i/ /res/ /ctx/ +foreign import ccall "ca.h ca_i"+  ca_i :: Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_neg_i/ /res/ /ctx/ +--+-- Sets /res/ to the imaginary unit \(i = \sqrt{-1}\), or its negation+-- \(-i\). This creates a canonical representation of \(i\) as the+-- generator of the algebraic number field \(\mathbb{Q}(i)\).+foreign import ccall "ca.h ca_neg_i"+  ca_neg_i :: Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_pi/ /res/ /ctx/ +--+-- Sets /res/ to the constant \(\pi\). This creates an element of the+-- transcendental number field \(\mathbb{Q}(\pi)\).+foreign import ccall "ca.h ca_pi"+  ca_pi :: Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_pi_i/ /res/ /ctx/ +--+-- Sets /res/ to the constant \(\pi i\). This creates an element of the+-- composite field \(\mathbb{Q}(i,\pi)\) rather than representing \(\pi i\)+-- (or even \(2 \pi i\), which for some purposes would be more elegant) as+-- an atomic quantity.+foreign import ccall "ca.h ca_pi_i"+  ca_pi_i :: Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_euler/ /res/ /ctx/ +--+-- Sets /res/ to Euler\'s constant \(\gamma\). This creates an element of+-- the (transcendental?) number field \(\mathbb{Q}(\gamma)\).+foreign import ccall "ca.h ca_euler"+  ca_euler :: Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_unknown/ /res/ /ctx/ +--+-- Sets /res/ to the meta-value /Unknown/.+foreign import ccall "ca.h ca_unknown"+  ca_unknown :: Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_undefined/ /res/ /ctx/ +--+-- Sets /res/ to /Undefined/.+foreign import ccall "ca.h ca_undefined"+  ca_undefined :: Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_uinf/ /res/ /ctx/ +--+-- Sets /res/ to unsigned infinity \({\tilde \infty}\).+foreign import ccall "ca.h ca_uinf"+  ca_uinf :: Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_pos_inf/ /res/ /ctx/ +foreign import ccall "ca.h ca_pos_inf"+  ca_pos_inf :: Ptr CCa -> Ptr CCaCtx -> IO ()+  +-- | /ca_neg_inf/ /res/ /ctx/ +foreign import ccall "ca.h ca_neg_inf"+  ca_neg_inf :: Ptr CCa -> Ptr CCaCtx -> IO ()+  +-- | /ca_pos_i_inf/ /res/ /ctx/ +foreign import ccall "ca.h ca_pos_i_inf"+  ca_pos_i_inf :: Ptr CCa -> Ptr CCaCtx -> IO ()+  +-- | /ca_neg_i_inf/ /res/ /ctx/ +--+-- Sets /res/ to the signed infinity \(+\infty\), \(-\infty\),+-- \(+i \infty\) or \(-i \infty\).+foreign import ccall "ca.h ca_neg_i_inf"+  ca_neg_i_inf :: Ptr CCa -> Ptr CCaCtx -> IO ()++-- Assignment and conversion ---------------------------------------------------++-- | /ca_set/ /res/ /x/ /ctx/ +--+-- Sets /res/ to a copy of /x/.+foreign import ccall "ca.h ca_set"+  ca_set :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_set_si/ /res/ /v/ /ctx/ +foreign import ccall "ca.h ca_set_si"+  ca_set_si :: Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_set_ui/ /res/ /v/ /ctx/ +foreign import ccall "ca.h ca_set_ui"+  ca_set_ui :: Ptr CCa -> CULong -> Ptr CCaCtx -> IO ()+-- | /ca_set_fmpz/ /res/ /v/ /ctx/ +foreign import ccall "ca.h ca_set_fmpz"+  ca_set_fmpz :: Ptr CCa -> Ptr CFmpz -> Ptr CCaCtx -> IO ()+-- | /ca_set_fmpq/ /res/ /v/ /ctx/ +--+-- Sets /res/ to the integer or rational number /v/. This creates a+-- canonical representation of this number as an element of the trivial+-- field \(\mathbb{Q}\).+foreign import ccall "ca.h ca_set_fmpq"+  ca_set_fmpq :: Ptr CCa -> Ptr CFmpq -> Ptr CCaCtx -> IO ()++-- | /ca_set_d/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_set_d"+  ca_set_d :: Ptr CCa -> CDouble -> Ptr CCaCtx -> IO ()+-- | /ca_set_d_d/ /res/ /x/ /y/ /ctx/ +--+-- Sets /res/ to the value of /x/, or the complex value \(x + yi\). NaN is+-- interpreted as /Unknown/ (not /Undefined/).+foreign import ccall "ca.h ca_set_d_d"+  ca_set_d_d :: Ptr CCa -> CDouble -> CDouble -> Ptr CCaCtx -> IO ()++-- | /ca_transfer/ /res/ /res_ctx/ /src/ /src_ctx/ +--+-- Sets /res/ to /src/ where the corresponding context objects /res_ctx/+-- and /src_ctx/ may be different.+-- +-- This operation preserves the mathematical value represented by /src/,+-- but may result in a different internal representation depending on the+-- settings of the context objects.+foreign import ccall "ca.h ca_transfer"+  ca_transfer :: Ptr CCa -> Ptr CCaCtx -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- Conversion of algebraic numbers ---------------------------------------------++-- | /ca_set_qqbar/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the algebraic number /x/.+-- +-- If /x/ is rational, /res/ is set to the canonical representation as an+-- element in the trivial field \(\mathbb{Q}\).+-- +-- If /x/ is irrational, this function always sets /res/ to an element of a+-- univariate number field \(\mathbb{Q}(a)\). It will not, for example,+-- identify \(\sqrt{2} + \sqrt{3}\) as an element of+-- \(\mathbb{Q}(\sqrt{2}, \sqrt{3})\). However, it may attempt to find a+-- simpler number field than that generated by /x/ itself. For example:+-- +-- -   If /x/ is quadratic, it will be expressed as an element of+--     \(\mathbb{Q}(\sqrt{N})\) where /N/ has no small repeated factors+--     (obtained by performing a smooth factorization of the discriminant).+-- -   TODO: if possible, coerce /x/ to a low-degree cyclotomic field.+foreign import ccall "ca.h ca_set_qqbar"+  ca_set_qqbar :: Ptr CCa -> Ptr CQQbar -> Ptr CCaCtx -> IO ()++-- | /ca_get_fmpz/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_get_fmpz"+  ca_get_fmpz :: Ptr CFmpz -> Ptr CCa -> Ptr CCaCtx -> IO CInt+  +-- | /ca_get_fmpq/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_get_fmpq"+  ca_get_fmpq :: Ptr CFmpq -> Ptr CCa -> Ptr CCaCtx -> IO CInt+  +-- | /ca_get_qqbar/ /res/ /x/ /ctx/ +--+-- Attempts to evaluate /x/ to an explicit integer, rational or algebraic+-- number. If successful, sets /res/ to this number and returns 1. If+-- unsuccessful, returns 0.+-- +-- The conversion certainly fails if /x/ does not represent an integer,+-- rational or algebraic number (respectively), but can also fail if /x/ is+-- too expensive to compute under the current evaluation limits. In+-- particular, the evaluation will be aborted if an intermediate algebraic+-- number (or more precisely, the resultant polynomial prior to+-- factorization) exceeds @CA_OPT_QQBAR_DEG_LIMIT@ or the coefficients+-- exceed some multiple of @CA_OPT_PREC_LIMIT@. Note that evaluation may+-- hit those limits even if the minimal polynomial for /x/ itself is small.+-- The conversion can also fail if no algorithm has been implemented for+-- the functions appearing in the construction of /x/.+foreign import ccall "ca.h ca_get_qqbar"+  ca_get_qqbar :: Ptr CQQbar -> Ptr CCa -> Ptr CCaCtx -> IO CInt++-- | /ca_can_evaluate_qqbar/ /x/ /ctx/ +--+-- Checks if @ca_get_qqbar@ has a chance to succeed. In effect, this checks+-- if all extension numbers are manifestly algebraic numbers (without doing+-- any evaluation).+foreign import ccall "ca.h ca_can_evaluate_qqbar"+  ca_can_evaluate_qqbar :: Ptr CCa -> Ptr CCaCtx -> IO CInt++-- Random generation -----------------------------------------------------------++-- | /ca_randtest_rational/ /res/ /state/ /bits/ /ctx/ +--+-- Sets /res/ to a random rational number with numerator and denominator up+-- to /bits/ bits in size.+foreign import ccall "ca.h ca_randtest_rational"+  ca_randtest_rational :: Ptr CCa -> Ptr CFRandState -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_randtest/ /res/ /state/ /depth/ /bits/ /ctx/ +--+-- Sets /res/ to a random number generated by evaluating a random+-- expression. The algorithm randomly selects between generating a+-- \"simple\" number (a random rational number or quadratic field element+-- with coefficients up to /bits/ in size, or a random builtin constant),+-- or if /depth/ is nonzero, applying a random arithmetic operation or+-- function to operands produced through recursive calls with /depth/ - 1.+-- The output is guaranteed to be a number, not a special value.+foreign import ccall "ca.h ca_randtest"+  ca_randtest :: Ptr CCa -> Ptr CFRandState -> CLong -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_randtest_special/ /res/ /state/ /depth/ /bits/ /ctx/ +--+-- Randomly generates either a special value or a number.+foreign import ccall "ca.h ca_randtest_special"+  ca_randtest_special :: Ptr CCa -> Ptr CFRandState -> CLong -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_randtest_same_nf/ /res/ /state/ /x/ /bits/ /den_bits/ /ctx/ +--+-- Sets /res/ to a random element in the same number field as /x/, with+-- numerator coefficients up to /bits/ in size and denominator up to+-- /den_bits/ in size. This function requires that /x/ is an element of an+-- absolute number field.+foreign import ccall "ca.h ca_randtest_same_nf"+  ca_randtest_same_nf :: Ptr CCa -> Ptr CFRandState -> Ptr CCa -> CLong -> CLong -> Ptr CCaCtx -> IO ()++-- $representation+--+-- The following functions deal with the representation of a @Ca@ and+-- hence can always be decided quickly and unambiguously. The return value+-- for predicates is 0 for false and 1 for true.++-- | /ca_equal_repr/ /x/ /y/ /ctx/ +--+-- Returns whether /x/ and /y/ have identical representation. For field+-- elements, this checks if /x/ and /y/ belong to the same formal field+-- (with generators having identical representation) and are represented by+-- the same rational function within that field.+-- +-- For special values, this tests equality of the special values, with+-- /Unknown/ handled as if it were a value rather than a meta-value: that+-- is, /Unknown/ = /Unknown/ gives 1, and /Unknown/ = /y/ gives 0 for any+-- other kind of value /y/. If neither /x/ nor /y/ is /Unknown/, then+-- representation equality implies that /x/ and /y/ describe to the same+-- mathematical value, but if either operand is /Unknown/, the result is+-- meaningless for mathematical comparison.+foreign import ccall "ca.h ca_equal_repr"+  ca_equal_repr :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO CInt++-- | /ca_cmp_repr/ /x/ /y/ /ctx/ +--+-- Compares the representations of /x/ and /y/ in a canonical sort order,+-- returning -1, 0 or 1. This only performs a lexicographic comparison of+-- the representations of /x/ and /y/; the return value does not say+-- anything meaningful about the numbers represented by /x/ and /y/.+foreign import ccall "ca.h ca_cmp_repr"+  ca_cmp_repr :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO CInt++-- | /ca_hash_repr/ /x/ /ctx/ +--+-- Hashes the representation of /x/.+foreign import ccall "ca.h ca_hash_repr"+  ca_hash_repr :: Ptr CCa -> Ptr CCaCtx -> IO CULong++-- | /ca_is_unknown/ /x/ /ctx/ +--+-- Returns whether /x/ is Unknown.+foreign import ccall "ca.h ca_is_unknown"+  ca_is_unknown :: Ptr CCa -> Ptr CCaCtx -> IO CInt++-- | /ca_is_special/ /x/ /ctx/ +--+-- Returns whether /x/ is a special value or metavalue (not a field+-- element).+foreign import ccall "ca.h ca_is_special"+  ca_is_special :: Ptr CCa -> Ptr CCaCtx -> IO CInt++-- | /ca_is_qq_elem/ /x/ /ctx/ +--+-- Returns whether /x/ is represented as an element of the rational field+-- \(\mathbb{Q}\).+foreign import ccall "ca.h ca_is_qq_elem"+  ca_is_qq_elem :: Ptr CCa -> Ptr CCaCtx -> IO CInt++-- | /ca_is_qq_elem_zero/ /x/ /ctx/ +foreign import ccall "ca.h ca_is_qq_elem_zero"+  ca_is_qq_elem_zero :: Ptr CCa -> Ptr CCaCtx -> IO CInt+-- | /ca_is_qq_elem_one/ /x/ /ctx/ +foreign import ccall "ca.h ca_is_qq_elem_one"+  ca_is_qq_elem_one :: Ptr CCa -> Ptr CCaCtx -> IO CInt+-- | /ca_is_qq_elem_integer/ /x/ /ctx/ +--+-- Returns whether /x/ is represented as the element 0, 1 or any integer in+-- the rational field \(\mathbb{Q}\).+foreign import ccall "ca.h ca_is_qq_elem_integer"+  ca_is_qq_elem_integer :: Ptr CCa -> Ptr CCaCtx -> IO CInt++-- | /ca_is_nf_elem/ /x/ /ctx/ +--+-- Returns whether /x/ is represented as an element of a univariate+-- algebraic number field \(\mathbb{Q}(a)\).+foreign import ccall "ca.h ca_is_nf_elem"+  ca_is_nf_elem :: Ptr CCa -> Ptr CCaCtx -> IO CInt++-- | /ca_is_cyclotomic_nf_elem/ /p/ /q/ /x/ /ctx/ +--+-- Returns whether /x/ is represented as an element of a univariate+-- cyclotomic field, i.e. \(\mathbb{Q}(a)\) where /a/ is a root of unity.+-- If /p/ and /q/ are not /NULL/ and /x/ is represented as an element of a+-- cyclotomic field, this also sets /p/ and /q/ to the minimal integers+-- with \(0 \le p < q\) such that the generating root of unity is+-- \(a = e^{2 \pi i p / q}\). Note that the answer 0 does not prove that+-- /x/ is not a cyclotomic number, and the order /q/ is also not+-- necessarily the generator of the /smallest/ cyclotomic field containing+-- /x/. For the purposes of this function, only nontrivial cyclotomic+-- fields count; the return value is 0 if /x/ is represented as a rational+-- number.+foreign import ccall "ca.h ca_is_cyclotomic_nf_elem"+  ca_is_cyclotomic_nf_elem :: Ptr CLong -> Ptr CULong -> Ptr CCa -> Ptr CCaCtx -> IO CInt++-- | /ca_is_generic_elem/ /x/ /ctx/ +--+-- Returns whether /x/ is represented as a generic field element; i.e. it+-- is not a special value, not represented as an element of the rational+-- field, and not represented as an element of a univariate algebraic+-- number field.+foreign import ccall "ca.h ca_is_generic_elem"+  ca_is_generic_elem :: Ptr CCa -> Ptr CCaCtx -> IO CInt++-- Value predicates ------------------------------------------------------------++-- The following predicates check a mathematical property which might not+-- be effectively decidable. The result is a @truth_t@ to allow+-- representing an unknown outcome.+--+-- | /ca_check_is_number/ /x/ /ctx/ +--+-- Tests if /x/ is a number. The result is @T_TRUE@ is /x/ is a field+-- element (and hence a complex number), @T_FALSE@ if /x/ is an infinity or+-- /Undefined/, and @T_UNKNOWN@ if /x/ is /Unknown/.+foreign import ccall "ca.h ca_check_is_number"+  ca_check_is_number :: Ptr CCa -> Ptr CCaCtx -> IO CTruth++-- | /ca_check_is_zero/ /x/ /ctx/ +foreign import ccall "ca.h ca_check_is_zero"+  ca_check_is_zero :: Ptr CCa -> Ptr CCaCtx -> IO CTruth+-- | /ca_check_is_one/ /x/ /ctx/ +foreign import ccall "ca.h ca_check_is_one"+  ca_check_is_one :: Ptr CCa -> Ptr CCaCtx -> IO CTruth+-- | /ca_check_is_neg_one/ /x/ /ctx/ +foreign import ccall "ca.h ca_check_is_neg_one"+  ca_check_is_neg_one :: Ptr CCa -> Ptr CCaCtx -> IO CTruth+-- | /ca_check_is_i/ /x/ /ctx/ +foreign import ccall "ca.h ca_check_is_i"+  ca_check_is_i :: Ptr CCa -> Ptr CCaCtx -> IO CTruth+-- | /ca_check_is_neg_i/ /x/ /ctx/ +--+-- Tests if /x/ is equal to the number \(0\), \(1\), \(-1\), \(i\), or+-- \(-i\).+foreign import ccall "ca.h ca_check_is_neg_i"+  ca_check_is_neg_i :: Ptr CCa -> Ptr CCaCtx -> IO CTruth++-- | /ca_check_is_algebraic/ /x/ /ctx/ +foreign import ccall "ca.h ca_check_is_algebraic"+  ca_check_is_algebraic :: Ptr CCa -> Ptr CCaCtx -> IO CTruth+-- | /ca_check_is_rational/ /x/ /ctx/ +foreign import ccall "ca.h ca_check_is_rational"+  ca_check_is_rational :: Ptr CCa -> Ptr CCaCtx -> IO CTruth+-- | /ca_check_is_integer/ /x/ /ctx/ +--+-- Tests if /x/ is respectively an algebraic number, a rational number, or+-- an integer.+foreign import ccall "ca.h ca_check_is_integer"+  ca_check_is_integer :: Ptr CCa -> Ptr CCaCtx -> IO CTruth++-- | /ca_check_is_real/ /x/ /ctx/ +--+-- Tests if /x/ is a real number. Warning: this returns @T_FALSE@ if /x/ is+-- an infinity with real sign.+foreign import ccall "ca.h ca_check_is_real"+  ca_check_is_real :: Ptr CCa -> Ptr CCaCtx -> IO CTruth++-- | /ca_check_is_negative_real/ /x/ /ctx/ +--+-- Tests if /x/ is a negative real number. Warning: this returns @T_FALSE@+-- if /x/ is negative infinity.+foreign import ccall "ca.h ca_check_is_negative_real"+  ca_check_is_negative_real :: Ptr CCa -> Ptr CCaCtx -> IO CTruth++-- | /ca_check_is_imaginary/ /x/ /ctx/ +--+-- Tests if /x/ is an imaginary number. Warning: this returns @T_FALSE@ if+-- /x/ is an infinity with imaginary sign.+foreign import ccall "ca.h ca_check_is_imaginary"+  ca_check_is_imaginary :: Ptr CCa -> Ptr CCaCtx -> IO CTruth++-- | /ca_check_is_undefined/ /x/ /ctx/ +--+-- Tests if /x/ is the special value /Undefined/.+foreign import ccall "ca.h ca_check_is_undefined"+  ca_check_is_undefined :: Ptr CCa -> Ptr CCaCtx -> IO CTruth++-- | /ca_check_is_infinity/ /x/ /ctx/ +--+-- Tests if /x/ is any infinity (unsigned or signed).+foreign import ccall "ca.h ca_check_is_infinity"+  ca_check_is_infinity :: Ptr CCa -> Ptr CCaCtx -> IO CTruth++-- | /ca_check_is_uinf/ /x/ /ctx/ +--+-- Tests if /x/ is unsigned infinity \({\tilde \infty}\).+foreign import ccall "ca.h ca_check_is_uinf"+  ca_check_is_uinf :: Ptr CCa -> Ptr CCaCtx -> IO CTruth++-- | /ca_check_is_signed_inf/ /x/ /ctx/ +--+-- Tests if /x/ is any signed infinity.+foreign import ccall "ca.h ca_check_is_signed_inf"+  ca_check_is_signed_inf :: Ptr CCa -> Ptr CCaCtx -> IO CTruth++-- | /ca_check_is_pos_inf/ /x/ /ctx/ +foreign import ccall "ca.h ca_check_is_pos_inf"+  ca_check_is_pos_inf :: Ptr CCa -> Ptr CCaCtx -> IO CTruth+-- | /ca_check_is_neg_inf/ /x/ /ctx/ +foreign import ccall "ca.h ca_check_is_neg_inf"+  ca_check_is_neg_inf :: Ptr CCa -> Ptr CCaCtx -> IO CTruth+-- | /ca_check_is_pos_i_inf/ /x/ /ctx/ +foreign import ccall "ca.h ca_check_is_pos_i_inf"+  ca_check_is_pos_i_inf :: Ptr CCa -> Ptr CCaCtx -> IO CTruth+-- | /ca_check_is_neg_i_inf/ /x/ /ctx/ +--+-- Tests if /x/ is equal to the signed infinity \(+\infty\), \(-\infty\),+-- \(+i \infty\), \(-i \infty\), respectively.+foreign import ccall "ca.h ca_check_is_neg_i_inf"+  ca_check_is_neg_i_inf :: Ptr CCa -> Ptr CCaCtx -> IO CTruth++-- Comparisons -----------------------------------------------------------------++-- | /ca_check_equal/ /x/ /y/ /ctx/ +--+-- Tests \(x = y\) as a mathematical equality. The result is @T_UNKNOWN@ if+-- either operand is /Unknown/. The result may also be @T_UNKNOWN@ if /x/+-- and /y/ are numerically indistinguishable and cannot be proved equal or+-- unequal by an exact computation.+foreign import ccall "ca.h ca_check_equal"+  ca_check_equal :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO CTruth++-- | /ca_check_lt/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_check_lt"+  ca_check_lt :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO CTruth+  +-- | /ca_check_le/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_check_le"+  ca_check_le :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO CTruth+  +-- | /ca_check_gt/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_check_gt"+  ca_check_gt :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO CTruth+-- | /ca_check_ge/ /x/ /y/ /ctx/ +--+-- Compares /x/ and /y/, implementing the respective operations \(x < y\),+-- \(x \le y\), \(x > y\), \(x \ge y\). Only real numbers and \(-\infty\)+-- and \(+\infty\) are considered comparable. The result is @T_FALSE@ (not+-- @T_UNKNOWN@) if either operand is not comparable (being a nonreal+-- complex number, unsigned infinity, or undefined).+foreign import ccall "ca.h ca_check_ge"+  ca_check_ge :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO CTruth++-- Field structure operations --------------------------------------------------++-- | /ca_merge_fields/ /resx/ /resy/ /x/ /y/ /ctx/ +--+-- Sets /resx/ and /resy/ to copies of /x/ and /y/ coerced to a common+-- field. Both /x/ and /y/ must be field elements (not special values).+-- +-- In the present implementation, this simply merges the lists of+-- generators, avoiding duplication. In the future, it will be able to+-- eliminate generators satisfying algebraic relations.+foreign import ccall "ca.h ca_merge_fields"+  ca_merge_fields :: Ptr CCa -> Ptr CCa -> Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_condense_field/ /res/ /ctx/ +--+-- Attempts to demote the value of /res/ to a trivial subfield of its+-- current field by removing unused generators. In particular, this demotes+-- any obviously rational value to the trivial field \(\mathbb{Q}\).+-- +-- This function is applied automatically in most operations (arithmetic+-- operations, etc.).+foreign import ccall "ca.h ca_condense_field"+  ca_condense_field :: Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_is_gen_as_ext/ /x/ /ctx/ +--+-- If /x/ is a generator of its formal field,+-- \(x = a_k \in \mathbb{Q}(a_1,\ldots,a_n)\), returns a pointer to the+-- extension number defining \(a_k\). If /x/ is not a generator, returns+-- /NULL/.+foreign import ccall "ca.h ca_is_gen_as_ext"+  ca_is_gen_as_ext :: Ptr CCa -> Ptr CCaCtx -> IO (Ptr CCa)++-- Arithmetic ------------------------------------------------------------------++-- | /ca_neg/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the negation of /x/. For numbers, this operation amounts+-- to a direct negation within the formal field. For a signed infinity+-- \(c \infty\), negation gives \((-c) \infty\); all other special values+-- are unchanged.+foreign import ccall "ca.h ca_neg"+  ca_neg :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_add_fmpq/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_add_fmpq"+  ca_add_fmpq :: Ptr CCa -> Ptr CCa -> Ptr CFmpq -> Ptr CCaCtx -> IO ()+  +-- | /ca_add_fmpz/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_add_fmpz"+  ca_add_fmpz :: Ptr CCa -> Ptr CCa -> Ptr CFmpz -> Ptr CCaCtx -> IO ()+  +-- | /ca_add_ui/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_add_ui"+  ca_add_ui :: Ptr CCa -> Ptr CCa -> CULong -> Ptr CCaCtx -> IO ()+  +-- | /ca_add_si/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_add_si"+  ca_add_si :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_add/ /res/ /x/ /y/ /ctx/ +--+-- Sets /res/ to the sum of /x/ and /y/. For special values, the following+-- rules apply (c infty denotes a signed infinity, \(|c| = 1\)):+-- +-- -   \(c \infty + d \infty = c \infty\) if \(c = d\)+-- -   \(c \infty + d \infty = \text{Undefined}\) if \(c \ne d\)+-- -   \(\tilde \infty + c \infty = \tilde \infty + \tilde \infty = \text{Undefined}\)+-- -   \(c \infty + z = c \infty\) if \(z \in \mathbb{C}\)+-- -   \(\tilde \infty + z = \tilde \infty\) if \(z \in \mathbb{C}\)+-- -   \(z + \text{Undefined} = \text{Undefined}\) for any value /z/+--     (including /Unknown/)+-- +-- In any other case involving special values, or if the specific case+-- cannot be distinguished, the result is /Unknown/.+foreign import ccall "ca.h ca_add"+  ca_add :: Ptr CCa -> Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_sub_fmpq/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_sub_fmpq"+  ca_sub_fmpq :: Ptr CCa -> Ptr CCa -> Ptr CFmpq -> Ptr CCaCtx -> IO ()+-- | /ca_sub_fmpz/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_sub_fmpz"+  ca_sub_fmpz :: Ptr CCa -> Ptr CCa -> Ptr CFmpz -> Ptr CCaCtx -> IO ()+-- | /ca_sub_ui/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_sub_ui"+  ca_sub_ui :: Ptr CCa -> Ptr CCa -> CULong -> Ptr CCaCtx -> IO ()+-- | /ca_sub_si/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_sub_si"+  ca_sub_si :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_fmpq_sub/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_fmpq_sub"+  ca_fmpq_sub :: Ptr CCa -> Ptr CFmpq -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_fmpz_sub/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_fmpz_sub"+  ca_fmpz_sub :: Ptr CCa -> Ptr CFmpz -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_ui_sub/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_ui_sub"+  ca_ui_sub :: Ptr CCa -> CULong -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_si_sub/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_si_sub"+  ca_si_sub :: Ptr CCa -> CLong -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_sub/ /res/ /x/ /y/ /ctx/ +--+-- Sets /res/ to the difference of /x/ and /y/. This is equivalent to+-- computing \(x + (-y)\).+foreign import ccall "ca.h ca_sub"+  ca_sub :: Ptr CCa -> Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_mul_fmpq/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_mul_fmpq"+  ca_mul_fmpq :: Ptr CCa -> Ptr CCa -> Ptr CFmpq -> Ptr CCaCtx -> IO ()+-- | /ca_mul_fmpz/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_mul_fmpz"+  ca_mul_fmpz :: Ptr CCa -> Ptr CCa -> Ptr CFmpz -> Ptr CCaCtx -> IO ()+-- | /ca_mul_ui/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_mul_ui"+  ca_mul_ui :: Ptr CCa -> Ptr CCa -> CULong -> Ptr CCaCtx -> IO ()+-- | /ca_mul_si/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_mul_si"+  ca_mul_si :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_mul/ /res/ /x/ /y/ /ctx/ +--+-- Sets /res/ to the product of /x/ and /y/. For special values, the+-- following rules apply (c infty denotes a signed infinity, \(|c| = 1\)):+-- +-- -   \(c \infty \cdot d \infty = c d \infty\)+-- -   \(c \infty \cdot \tilde \infty = \tilde \infty\)+-- -   \(\tilde \infty \cdot \tilde \infty = \tilde \infty\)+-- -   \(c \infty \cdot z = \operatorname{sgn}(z) c \infty\) if+--     \(z \in \mathbb{C} \setminus \{0\}\)+-- -   \(c \infty \cdot 0 = \text{Undefined}\)+-- -   \(\tilde \infty \cdot 0 = \text{Undefined}\)+-- -   \(z \cdot  \text{Undefined} = \text{Undefined}\) for any value /z/+--     (including /Unknown/)+-- +-- In any other case involving special values, or if the specific case+-- cannot be distinguished, the result is /Unknown/.+foreign import ccall "ca.h ca_mul"+  ca_mul :: Ptr CCa -> Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_inv/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the multiplicative inverse of /x/. In a univariate+-- algebraic number field, this always produces a rational denominator, but+-- the denominator might not be rationalized in a multivariate field. For+-- special values and zero, the following rules apply:+-- +-- -   \(1 / (c \infty) = 1 / \tilde \infty = 0\)+-- -   \(1 / 0 = \tilde \infty\)+-- -   \(1 / \text{Undefined} = \text{Undefined}\)+-- -   \(1 / \text{Unknown} = \text{Unknown}\)+-- +-- If it cannot be determined whether /x/ is zero or nonzero, the result is+-- /Unknown/.+foreign import ccall "ca.h ca_inv"+  ca_inv :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_fmpq_div/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_fmpq_div"+  ca_fmpq_div :: Ptr CCa -> Ptr CFmpq -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_fmpz_div/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_fmpz_div"+  ca_fmpz_div :: Ptr CCa -> Ptr CFmpz -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_ui_div/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_ui_div"+  ca_ui_div :: Ptr CCa -> CULong -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_si_div/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_si_div"+  ca_si_div :: Ptr CCa -> CLong -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_div_fmpq/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_div_fmpq"+  ca_div_fmpq :: Ptr CCa -> Ptr CCa -> Ptr CFmpq -> Ptr CCaCtx -> IO ()+-- | /ca_div_fmpz/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_div_fmpz"+  ca_div_fmpz :: Ptr CCa -> Ptr CCa -> Ptr CFmpz -> Ptr CCaCtx -> IO ()+-- | /ca_div_ui/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_div_ui"+  ca_div_ui :: Ptr CCa -> Ptr CCa -> CULong -> Ptr CCaCtx -> IO ()+-- | /ca_div_si/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_div_si"+  ca_div_si :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_div/ /res/ /x/ /y/ /ctx/ +--+-- Sets /res/ to the quotient of /x/ and /y/. This is equivalent to+-- computing \(x \cdot (1 / y)\). For special values and division by zero,+-- this implies the following rules (c infty denotes a signed infinity,+-- \(|c| = 1\)):+-- +-- -   \((c \infty) / (d \infty) = (c \infty) / \tilde \infty = \tilde \infty / (c \infty) = \tilde \infty / \tilde \infty = \text{Undefined}\)+-- -   \(c \infty / z = (c / \operatorname{sgn}(z)) \infty\) if+--     \(z \in \mathbb{C} \setminus \{0\}\)+-- -   \(c \infty / 0 = \tilde \infty / 0 = \tilde \infty\)+-- -   \(z / (c \infty) = z / \tilde \infty = 0\) if \(z \in \mathbb{C}\)+-- -   \(z / 0 = \tilde \infty\) if \(z \in \mathbb{C} \setminus \{0\}\)+-- -   \(0 / 0 = \text{Undefined}\)+-- -   \(z / \text{Undefined} = \text{Undefined}\) for any value /z/+--     (including /Unknown/)+-- -   \(\text{Undefined} / z = \text{Undefined}\) for any value /z/+--     (including /Unknown/)+-- +-- In any other case involving special values, or if the specific case+-- cannot be distinguished, the result is /Unknown/.+foreign import ccall "ca.h ca_div"+  ca_div :: Ptr CCa -> Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_dot/ /res/ /initial/ /subtract/ /x/ /xstep/ /y/ /ystep/ /len/ /ctx/ +--+-- Computes the dot product of the vectors /x/ and /y/, setting /res/ to+-- \(s + (-1)^{subtract} \sum_{i=0}^{len-1} x_i y_i\).+-- +-- The initial term /s/ is optional and can be omitted by passing /NULL/+-- (equivalently, \(s = 0\)). The parameter /subtract/ must be 0 or 1. The+-- length /len/ is allowed to be negative, which is equivalent to a length+-- of zero. The parameters /xstep/ or /ystep/ specify a step length for+-- traversing subsequences of the vectors /x/ and /y/; either can be+-- negative to step in the reverse direction starting from the initial+-- pointer. Aliasing is allowed between /res/ and /s/ but not between /res/+-- and the entries of /x/ and /y/.+foreign import ccall "ca.h ca_dot"+  ca_dot :: Ptr CCa -> Ptr CCa -> CInt -> Ptr CCa -> CLong -> Ptr CCa -> CLong -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_fmpz_poly_evaluate/ /res/ /poly/ /x/ /ctx/ +foreign import ccall "ca.h ca_fmpz_poly_evaluate"+  ca_fmpz_poly_evaluate :: Ptr CCa -> Ptr CFmpzPoly -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_fmpq_poly_evaluate/ /res/ /poly/ /x/ /ctx/ +--+-- Sets /res/ to the polynomial /poly/ evaluated at /x/.+foreign import ccall "ca.h ca_fmpq_poly_evaluate"+  ca_fmpq_poly_evaluate :: Ptr CCa -> Ptr CFmpqPoly -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_fmpz_mpoly_evaluate_horner/ /res/ /f/ /x/ /mctx/ /ctx/ +foreign import ccall "ca.h ca_fmpz_mpoly_evaluate_horner"+  ca_fmpz_mpoly_evaluate_horner :: Ptr CCa -> Ptr CFmpzMPoly -> Ptr CCa -> Ptr CFmpzMPolyCtx -> Ptr CCaCtx -> IO ()+-- -- | /ca_fmpz_mpoly_evaluate_iter/ /res/ /f/ /x/ /mctx/ /ctx/ +-- foreign import ccall "ca.h ca_fmpz_mpoly_evaluate_iter"+--   ca_fmpz_mpoly_evaluate_iter :: Ptr CCa -> Ptr CFmpzMPoly -> Ptr CCa -> Ptr CFmpzMPolyCtx -> Ptr CCaCtx -> IO ()+-- | /ca_fmpz_mpoly_evaluate/ /res/ /f/ /x/ /mctx/ /ctx/ +--+-- Sets /res/ to the multivariate polynomial /f/ evaluated at the vector of+-- arguments /x/.+foreign import ccall "ca.h ca_fmpz_mpoly_evaluate"+  ca_fmpz_mpoly_evaluate :: Ptr CCa -> Ptr CFmpzMPoly -> Ptr CCa -> Ptr CFmpzMPolyCtx -> Ptr CCaCtx -> IO ()++-- | /ca_fmpz_mpoly_q_evaluate/ /res/ /f/ /x/ /mctx/ /ctx/ +--+-- Sets /res/ to the multivariate rational function /f/ evaluated at the+-- vector of arguments /x/.+foreign import ccall "ca.h ca_fmpz_mpoly_q_evaluate"+  ca_fmpz_mpoly_q_evaluate :: Ptr CCa -> Ptr CFmpzMPolyQ -> Ptr CCa -> Ptr CFmpzMPolyCtx -> Ptr CCaCtx -> IO ()++-- | /ca_fmpz_mpoly_q_evaluate_no_division_by_zero/ /res/ /f/ /x/ /mctx/ /ctx/ +foreign import ccall "ca.h ca_fmpz_mpoly_q_evaluate_no_division_by_zero"+  ca_fmpz_mpoly_q_evaluate_no_division_by_zero :: Ptr CCa -> Ptr CFmpzMPolyQ -> Ptr CCa -> Ptr CFmpzMPolyCtx -> Ptr CCaCtx -> IO ()+-- | /ca_inv_no_division_by_zero/ /res/ /x/ /ctx/ +--+-- These functions behave like the normal arithmetic functions, but assume+-- (and do not check) that division by zero cannot occur. Division by zero+-- will result in undefined behavior.+foreign import ccall "ca.h ca_inv_no_division_by_zero"+  ca_inv_no_division_by_zero :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- Powers and roots ------------------------------------------------------------++-- | /ca_sqr/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the square of /x/.+foreign import ccall "ca.h ca_sqr"+  ca_sqr :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_pow_fmpq/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_pow_fmpq"+  ca_pow_fmpq :: Ptr CCa -> Ptr CCa -> Ptr CFmpq -> Ptr CCaCtx -> IO ()+-- | /ca_pow_fmpz/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_pow_fmpz"+  ca_pow_fmpz :: Ptr CCa -> Ptr CCa -> Ptr CFmpz -> Ptr CCaCtx -> IO ()+-- | /ca_pow_ui/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_pow_ui"+  ca_pow_ui :: Ptr CCa -> Ptr CCa -> CULong -> Ptr CCaCtx -> IO ()+-- | /ca_pow_si/ /res/ /x/ /y/ /ctx/ +foreign import ccall "ca.h ca_pow_si"+  ca_pow_si :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_pow/ /res/ /x/ /y/ /ctx/ +--+-- Sets /res/ to /x/ raised to the power /y/. Handling of special values is+-- not yet implemented.+foreign import ccall "ca.h ca_pow"+  ca_pow :: Ptr CCa -> Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_pow_si_arithmetic/ /res/ /x/ /n/ /ctx/ +--+-- Sets /res/ to /x/ raised to the power /n/. Whereas @ca_pow@, @ca_pow_si@+-- etc. may create \(x^n\) as an extension number if /n/ is large, this+-- function always perform the exponentiation using field arithmetic.+foreign import ccall "ca.h ca_pow_si_arithmetic"+  ca_pow_si_arithmetic :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_sqrt_inert/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_sqrt_inert"+  ca_sqrt_inert :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_sqrt_nofactor/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_sqrt_nofactor"+  ca_sqrt_nofactor :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_sqrt_factor/ /res/ /x/ /flags/ /ctx/ +foreign import ccall "ca.h ca_sqrt_factor"+  ca_sqrt_factor :: Ptr CCa -> Ptr CCa -> CULong -> Ptr CCaCtx -> IO ()+-- | /ca_sqrt/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the principal square root of /x/.+-- +-- For special values, the following definitions apply:+-- +-- -   \(\sqrt{c \infty} = \sqrt{c} \infty\)+-- -   \(\sqrt{\tilde \infty} = \tilde \infty\).+-- -   Both /Undefined/ and /Unknown/ map to themselves.+-- +-- The /inert/ version outputs the generator in the formal field+-- \(\mathbb{Q}(\sqrt{x})\) without simplifying.+-- +-- The /factor/ version writes \(x = A^2 B\) in \(K\) where \(K\) is the+-- field of /x/, and outputs \(A \sqrt{B}\) or \(-A \sqrt{B}\) (whichever+-- gives the correct sign) as an element of \(K(\sqrt{B})\) or some+-- subfield thereof. This factorization is only a heuristic and is not+-- guaranteed to make \(B\) minimal. Factorization options can be passed+-- through to /flags/: see @ca_factor@ for details.+-- +-- The /nofactor/ version will not perform a general factorization, but may+-- still perform other simplifications. It may in particular attempt to+-- simplify \(\sqrt{x}\) to a single element in \(\overline{\mathbb{Q}}\).+foreign import ccall "ca.h ca_sqrt"+  ca_sqrt :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_sqrt_ui/ /res/ /n/ /ctx/ +--+-- Sets /res/ to the principal square root of /n/.+foreign import ccall "ca.h ca_sqrt_ui"+  ca_sqrt_ui :: Ptr CCa -> CULong -> Ptr CCaCtx -> IO ()++-- Complex parts ---------------------------------------------------------------++-- | /ca_abs/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the absolute value of /x/.+-- +-- For special values, the following definitions apply:+-- +-- -   \(|c \infty| = |\tilde \infty| = +\infty\).+-- -   Both /Undefined/ and /Unknown/ map to themselves.+-- +-- This function will attempt to simplify its argument through an exact+-- computation. It may in particular attempt to simplify \(|x|\) to a+-- single element in \(\overline{\mathbb{Q}}\).+-- +-- In the generic case, this function outputs an element of the formal+-- field \(\mathbb{Q}(|x|)\).+foreign import ccall "ca.h ca_abs"+  ca_abs :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_sgn/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the sign of /x/, defined by+-- +-- \[`\]+-- \[\begin{aligned}+-- \operatorname{sgn}(x) = \begin{cases} 0 & x = 0 \\ \frac{x}{|x|} & x \ne 0 \end{cases}+-- \end{aligned}\]+-- +-- for numbers. For special values, the following definitions apply:+-- +-- -   \(\operatorname{sgn}(c \infty) = c\).+-- -   \(\operatorname{sgn}(\tilde \infty) = \operatorname{Undefined}\).+-- -   Both /Undefined/ and /Unknown/ map to themselves.+-- +-- This function will attempt to simplify its argument through an exact+-- computation. It may in particular attempt to simplify+-- \(\operatorname{sgn}(x)\) to a single element in+-- \(\overline{\mathbb{Q}}\).+-- +-- In the generic case, this function outputs an element of the formal+-- field \(\mathbb{Q}(\operatorname{sgn}(x))\).+foreign import ccall "ca.h ca_sgn"+  ca_sgn :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_csgn/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the extension of the real sign function taking the value 1+-- for /z/ strictly in the right half plane, -1 for /z/ strictly in the+-- left half plane, and the sign of the imaginary part when /z/ is on the+-- imaginary axis. Equivalently,+-- \(\operatorname{csgn}(z) = z / \sqrt{z^2}\) except that the value is 0+-- when /z/ is exactly zero. This function gives /Undefined/ for unsigned+-- infinity and+-- \(\operatorname{csgn}(\operatorname{sgn}(c \infty)) = \operatorname{csgn}(c)\)+-- for signed infinities.+foreign import ccall "ca.h ca_csgn"+  ca_csgn :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_arg/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the complex argument (phase) of /x/, normalized to the+-- range \((-\pi, +\pi]\). The argument of 0 is defined as 0. For special+-- values, the following definitions apply:+-- +-- -   \(\operatorname{arg}(c \infty) = \operatorname{arg}(c)\).+-- -   \(\operatorname{arg}(\tilde \infty) = \operatorname{Undefined}\).+-- -   Both /Undefined/ and /Unknown/ map to themselves.+foreign import ccall "ca.h ca_arg"+  ca_arg :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_re/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the real part of /x/. The result is /Undefined/ if /x/ is+-- any infinity (including a real infinity).+foreign import ccall "ca.h ca_re"+  ca_re :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_im/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the imaginary part of /x/. The result is /Undefined/ if+-- /x/ is any infinity (including an imaginary infinity).+foreign import ccall "ca.h ca_im"+  ca_im :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_conj_deep/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_conj_deep"+  ca_conj_deep :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_conj_shallow/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_conj_shallow"+  ca_conj_shallow :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_conj/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the complex conjugate of /x/. The /shallow/ version+-- creates a new extension element \(\overline{x}\) unless /x/ can be+-- trivially conjugated in-place in the existing field. The /deep/ version+-- recursively conjugates the extension numbers in the field of /x/.+foreign import ccall "ca.h ca_conj"+  ca_conj :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_floor/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the floor function of /x/. The result is /Undefined/ if+-- /x/ is any infinity (including a real infinity). For complex numbers,+-- this is presently defined to take the floor of the real part.+foreign import ccall "ca.h ca_floor"+  ca_floor :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_ceil/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the ceiling function of /x/. The result is /Undefined/ if+-- /x/ is any infinity (including a real infinity). For complex numbers,+-- this is presently defined to take the ceiling of the real part.+foreign import ccall "ca.h ca_ceil"+  ca_ceil :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- Exponentials and logarithms -------------------------------------------------++-- | /ca_exp/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the exponential function of /x/.+-- +-- For special values, the following definitions apply:+-- +-- -   \(e^{+\infty} = +\infty\)+-- -   \(e^{c \infty} = \tilde \infty\) if+--     \(0 < \operatorname{Re}(c) < 1\).+-- -   \(e^{c \infty} = 0\) if \(\operatorname{Re}(c) < 0\).+-- -   \(e^{c \infty} = \text{Undefined}\) if \(\operatorname{Re}(c) = 0\).+-- -   \(e^{\tilde \infty} = \text{Undefined}\).+-- -   Both /Undefined/ and /Unknown/ map to themselves.+-- +-- The following symbolic simplifications are performed automatically:+-- +-- -   \(e^0 = 1\)+-- -   \(e^{\log(z)} = z\)+-- -   \(e^{(p/q) \log(z)} = z^{p/q}\) (for rational \(p/q\))+-- -   \(e^{(p/q) \pi i}\) = algebraic root of unity (for small rational+--     \(p/q\))+-- +-- In the generic case, this function outputs an element of the formal+-- field \(\mathbb{Q}(e^x)\).+foreign import ccall "ca.h ca_exp"+  ca_exp :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_log/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the natural logarithm of /x/.+-- +-- For special values and at the origin, the following definitions apply:+-- +-- -   For any infinity, \(\log(c\infty) = \log(\tilde \infty) = +\infty\).+-- -   \(\log(0) = -\infty\). The result is /Unknown/ if deciding \(x = 0\)+--     fails.+-- -   Both /Undefined/ and /Unknown/ map to themselves.+-- +-- The following symbolic simplifications are performed automatically:+-- +-- -   \(\log(1) = 0\)+-- -   \(\log\left(e^z\right) = z + 2 \pi i k\)+-- -   \(\log\left(\sqrt{z}\right) = \tfrac{1}{2} \log(z) + 2 \pi i k\)+-- -   \(\log\left(z^a\right) = a \log(z) + 2 \pi i k\)+-- -   \(\log(x) = \log(-x) + \pi i\) for negative real /x/+-- +-- In the generic case, this function outputs an element of the formal+-- field \(\mathbb{Q}(\log(x))\).+foreign import ccall "ca.h ca_log"+  ca_log :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- Trigonometric functions -----------------------------------------------------++-- | /ca_sin_cos_exponential/ /res1/ /res2/ /x/ /ctx/ +foreign import ccall "ca.h ca_sin_cos_exponential"+  ca_sin_cos_exponential :: Ptr CCa -> Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_sin_cos_direct/ /res1/ /res2/ /x/ /ctx/ +foreign import ccall "ca.h ca_sin_cos_direct"+  ca_sin_cos_direct :: Ptr CCa -> Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_sin_cos_tangent/ /res1/ /res2/ /x/ /ctx/ +foreign import ccall "ca.h ca_sin_cos_tangent"+  ca_sin_cos_tangent :: Ptr CCa -> Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_sin_cos/ /res1/ /res2/ /x/ /ctx/ +--+-- Sets /res1/ to the sine of /x/ and /res2/ to the cosine of /x/. Either+-- /res1/ or /res2/ can be /NULL/ to compute only the other function.+-- Various representations are implemented:+-- +-- -   The /exponential/ version expresses the sine and cosine in terms of+--     complex exponentials. Simple algebraic values will simplify to+--     rational numbers or elements of cyclotomic fields.+-- -   The /direct/ method expresses the sine and cosine in terms of the+--     original functions (perhaps after applying some symmetry+--     transformations, which may interchange sin and cos). Extremely+--     simple algebraic values will automatically simplify to elements of+--     real algebraic number fields.+-- -   The /tangent/ version expresses the sine and cosine in terms of+--     \(\tan(x/2)\), perhaps after applying some symmetry transformations.+--     Extremely simple algebraic values will automatically simplify to+--     elements of real algebraic number fields.+-- +-- By default, the standard function uses the /exponential/ representation+-- as this typically works best for field arithmetic and simplifications,+-- although it has the disadvantage of introducing complex numbers where+-- real numbers would be sufficient. The behavior of the standard function+-- can be changed using the @ca_opt_trigformM@ context setting.+-- +-- For special values, the following definitions apply:+-- +-- -   \(\sin(\pm i \infty) = \pm i \infty\)+-- -   \(\cos(\pm i \infty) = +\infty\)+-- -   All other infinities give \(\operatorname{Undefined}\)+foreign import ccall "ca.h ca_sin_cos"+  ca_sin_cos :: Ptr CCa -> Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_sin/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_sin"+  ca_sin :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_cos/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the sine or cosine of /x/. These functions are shortcuts+-- for @ca_sin_cos@.+foreign import ccall "ca.h ca_cos"+  ca_cos :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_tan_sine_cosine/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_tan_sine_cosine"+  ca_tan_sine_cosine :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_tan_exponential/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_tan_exponential"+  ca_tan_exponential :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_tan_direct/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_tan_direct"+  ca_tan_direct :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_tan/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the tangent of /x/. The /sine_cosine/ version evaluates+-- the tangent as a quotient of a sine and cosine, the /direct/ version+-- evaluates it directly as a tangent (possibly after transforming the+-- variable), and the /exponential/ version evaluates it in terms of+-- complex exponentials. Simple algebraic values will automatically+-- simplify to elements of trigonometric or cyclotomic number fields.+-- +-- By default, the standard function uses the /exponential/ representation+-- as this typically works best for field arithmetic and simplifications,+-- although it has the disadvantage of introducing complex numbers where+-- real numbers would be sufficient. The behavior of the standard function+-- can be changed using the @CA_OPT_TRIG_FORM@ context setting.+-- +-- For special values, the following definitions apply:+-- +-- -   At poles, \(\tan((n+\tfrac{1}{2}) \pi) = \tilde \infty\)+-- -   \(\tan(e^{i \theta} \infty) = +i, \quad 0 < \theta < \pi\)+-- -   \(\tan(e^{i \theta} \infty) = -i, \quad -\pi < \theta < 0\)+-- -   \(\tan(\pm \infty) = \tan(\tilde \infty) = \operatorname{Undefined}\)+foreign import ccall "ca.h ca_tan"+  ca_tan :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_cot/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the cotangent /x/. This is equivalent to computing the+-- reciprocal of the tangent.+foreign import ccall "ca.h ca_cot"+  ca_cot :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_atan_logarithm/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_atan_logarithm"+  ca_atan_logarithm :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_atan_direct/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_atan_direct"+  ca_atan_direct :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_atan/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the inverse tangent of /x/.+-- +-- The /direct/ version expresses the result as an inverse tangent+-- (possibly after transforming the variable). The /logarithm/ version+-- expresses it in terms of complex logarithms. Simple algebraic inputs+-- will automatically simplify to rational multiples of \(\pi\).+-- +-- By default, the standard function uses the /logarithm/ representation as+-- this typically works best for field arithmetic and simplifications,+-- although it has the disadvantage of introducing complex numbers where+-- real numbers would be sufficient. The behavior of the standard function+-- can be changed using the @CA_OPT_TRIG_FORM@ context setting (exponential+-- mode results in logarithmic forms).+-- +-- For special values, the following definitions apply:+-- +-- -   \(\operatorname{atan}(\pm i) = \pm i \infty\)+-- -   \(\operatorname{atan}(c \infty) = \operatorname{csgn}(c) \pi / 2\)+-- -   \(\operatorname{atan}(\tilde \infty) = \operatorname{Undefined}\)+foreign import ccall "ca.h ca_atan"+  ca_atan :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_asin_logarithm/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_asin_logarithm"+  ca_asin_logarithm :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_acos_logarithm/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_acos_logarithm"+  ca_acos_logarithm :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_asin_direct/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_asin_direct"+  ca_asin_direct :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_acos_direct/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_acos_direct"+  ca_acos_direct :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_asin/ /res/ /x/ /ctx/ +foreign import ccall "ca.h ca_asin"+  ca_asin :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_acos/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the inverse sine (respectively, cosine) of /x/.+-- +-- The /direct/ version expresses the result as an inverse sine or cosine+-- (possibly after transforming the variable). The /logarithm/ version+-- expresses it in terms of complex logarithms. Simple algebraic inputs+-- will automatically simplify to rational multiples of \(\pi\).+-- +-- By default, the standard function uses the /logarithm/ representation as+-- this typically works best for field arithmetic and simplifications,+-- although it has the disadvantage of introducing complex numbers where+-- real numbers would be sufficient. The behavior of the standard function+-- can be changed using the @CA_OPT_TRIG_FORM@ context setting (exponential+-- mode results in logarithmic forms).+-- +-- The inverse cosine is presently implemented as+-- \(\operatorname{acos}(x) = \pi/2 - \operatorname{asin}(x)\).+foreign import ccall "ca.h ca_acos"+  ca_acos :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- Special functions -----------------------------------------------------------++-- | /ca_gamma/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the gamma function of /x/.+foreign import ccall "ca.h ca_gamma"+  ca_gamma :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_erf/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the error function of /x/.+foreign import ccall "ca.h ca_erf"+  ca_erf :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_erfc/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the complementary error function of /x/.+foreign import ccall "ca.h ca_erfc"+  ca_erfc :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_erfi/ /res/ /x/ /ctx/ +--+-- Sets /res/ to the imaginary error function of /x/.+foreign import ccall "ca.h ca_erfi"+  ca_erfi :: Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- Numerical evaluation --------------------------------------------------------++-- | /ca_get_acb_raw/ /res/ /x/ /prec/ /ctx/ +--+-- Sets /res/ to an enclosure of the numerical value of /x/. A working+-- precision of /prec/ bits is used internally for the evaluation, without+-- adaptive refinement. If /x/ is any special value, /res/ is set to+-- /acb_indeterminate/.+foreign import ccall "ca.h ca_get_acb_raw"+  ca_get_acb_raw :: Ptr CAcb -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_get_acb/ /res/ /x/ /prec/ /ctx/ +foreign import ccall "ca.h ca_get_acb"+  ca_get_acb :: Ptr CAcb -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()+  +-- | /ca_get_acb_accurate_parts/ /res/ /x/ /prec/ /ctx/ +--+-- Sets /res/ to an enclosure of the numerical value of /x/. The working+-- precision is increased adaptively to try to ensure /prec/ accurate bits+-- in the output. The /accurate_parts/ version tries to ensure /prec/+-- accurate bits for both the real and imaginary part separately.+-- +-- The refinement is stopped if the working precision exceeds+-- @CA_OPT_PREC_LIMIT@ (or twice the initial precision, if this is larger).+-- The user may call /acb_rel_accuracy_bits/ to check is the calculation+-- was successful.+-- +-- The output is not rounded down to /prec/ bits (to avoid unnecessary+-- double rounding); the user may call /acb_set_round/ when rounding is+-- desired.+foreign import ccall "ca.h ca_get_acb_accurate_parts"+  ca_get_acb_accurate_parts :: Ptr CAcb -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_get_decimal_str/ /x/ /digits/ /flags/ /ctx/ +--+-- Returns a decimal approximation of /x/ with precision up to /digits/.+-- The output is guaranteed to be correct within 1 ulp in the returned+-- digits, but the number of returned digits may be smaller than /digits/+-- if the numerical evaluation does not succeed.+-- +-- If /flags/ is set to 1, attempts to achieve full accuracy for both the+-- real and imaginary parts separately.+-- +-- If /x/ is not finite or a finite enclosure cannot be produced, returns+-- the string \"?\".+-- +-- The user should free the returned string with @flint_free@.+foreign import ccall "ca.h ca_get_decimal_str"+  ca_get_decimal_str :: Ptr CCa -> CLong -> CULong -> Ptr CCaCtx -> IO CString++-- Rewriting and simplification ------------------------------------------------++-- | /ca_rewrite_complex_normal_form/ /res/ /x/ /deep/ /ctx/ +--+-- Sets /res/ to /x/ rewritten using standardizing transformations over the+-- complex numbers:+-- +-- -   Elementary functions are rewritten in terms of (complex)+--     exponentials, roots and logarithms+-- -   Complex parts are rewritten using logarithms, square roots, and+--     (deep) complex conjugates+-- -   Algebraic numbers are rewritten in terms of cyclotomic fields where+--     applicable+-- +-- If /deep/ is set, the rewriting is applied recursively to the tower of+-- extension numbers; otherwise, the rewriting is only applied to the+-- top-level extension numbers.+-- +-- The result is not a normal form in the strong sense (the same number can+-- have many possible representations even after applying this+-- transformation), but in practice this is a powerful heuristic for+-- simplification.+foreign import ccall "ca.h ca_rewrite_complex_normal_form"+  ca_rewrite_complex_normal_form :: Ptr CCa -> Ptr CCa -> CInt -> Ptr CCaCtx -> IO ()++-- Factorization ---------------------------------------------------------------++-- | /ca_factor_init/ /fac/ /ctx/ +--+-- Initializes /fac/ and sets it to the empty factorization (equivalent to+-- the number 1).+foreign import ccall "ca.h ca_factor_init"+  ca_factor_init :: Ptr CCaFactor -> Ptr CCaCtx -> IO ()++-- | /ca_factor_clear/ /fac/ /ctx/ +--+-- Clears the factorization structure /fac/.+foreign import ccall "ca.h ca_factor_clear"+  ca_factor_clear :: Ptr CCaFactor -> Ptr CCaCtx -> IO ()++foreign import ccall "ca.h &ca_factor_clear"+  p_ca_factor_clear :: FunPtr (Ptr CCaFactor -> Ptr CCaCtx -> IO ())++-- | /ca_factor_one/ /fac/ /ctx/ +--+-- Sets /fac/ to the empty factorization (equivalent to the number 1).+foreign import ccall "ca.h ca_factor_one"+  ca_factor_one :: Ptr CCaFactor -> Ptr CCaCtx -> IO ()++-- | /ca_factor_print/ /fac/ /ctx/ +--+-- Prints a description of /fac/ to standard output.+foreign import ccall "ca.h ca_factor_print"+  ca_factor_print :: Ptr CCaFactor -> Ptr CCaCtx -> IO ()++-- | /ca_factor_insert/ /fac/ /base/ /exp/ /ctx/ +--+-- Inserts \(b^e\) into /fac/ where /b/ is given by /base/ and /e/ is given+-- by /exp/. If a base element structurally identical to /base/ already+-- exists in /fac/, the corresponding exponent is incremented by /exp/;+-- otherwise, this factor is appended.+foreign import ccall "ca.h ca_factor_insert"+  ca_factor_insert :: Ptr CCaFactor -> Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_factor_get_ca/ /res/ /fac/ /ctx/ +--+-- Expands /fac/ back to a single @ca_t@ by evaluating the powers and+-- multiplying out the result.+foreign import ccall "ca.h ca_factor_get_ca"+  ca_factor_get_ca :: Ptr CCa -> Ptr CCaFactor -> Ptr CCaCtx -> IO ()++-- | /ca_factor/ /res/ /x/ /flags/ /ctx/ +--+-- Sets /res/ to a factorization of /x/ of the form+-- \(x = b_1^{e_1} b_2^{e_2} \cdots b_n^{e_n}\). Requires that /x/ is not a+-- special value. The type of factorization is controlled by /flags/, which+-- can be set to a combination of constants in the following section.+foreign import ccall "ca.h ca_factor"+  ca_factor :: Ptr CCaFactor -> Ptr CCa -> CULong -> Ptr CCaCtx -> IO ()++-- Factorization options -------------------------------------------------------++-- $factorization_options+-- The following flags select the structural polynomial factorization+-- to perform over formal fields \(\mathbb{Q}(a_1,\ldots,a_n)\). Each+-- flag in the list strictly encompasses the factorization power of+-- the preceding flag, so it is unnecessary to pass more than one+-- flag.++type CaFactorOption = CULong++ca_factor_poly_none, ca_factor_poly_content, ca_factor_poly_sqf, ca_factor_poly_full, ca_factor_zz_none, ca_factor_zz_smooth, ca_factor_zz_full :: CaFactorOption++-- | /ca_factor_poly_none/+-- +-- No polynomial factorization at all.+-- +ca_factor_poly_none = #const CA_FACTOR_POLY_NONE+-- | /ca_factor_poly_content/+-- +-- Only extract the rational content.+-- +ca_factor_poly_content = #const CA_FACTOR_POLY_CONTENT+-- | /ca_factor_poly_sqf/+-- +-- Perform a squarefree factorization in addition to extracting+-- the rational content.+-- +ca_factor_poly_sqf = #const CA_FACTOR_POLY_SQF+-- | /ca_factor_poly_full/+-- +-- Perform a full multivariate polynomial factorization.+-- +-- The following flags select the factorization to perform over `\mathbb{Z}`.+-- Integer factorization is applied if *x* is an element of `\mathbb{Q}`, and to+-- the extracted rational content of polynomials.+-- Each flag in the list strictly encompasses the factorization power of+-- the preceding flag, so it is unnecessary to pass more than one flag.+-- +ca_factor_poly_full = #const CA_FACTOR_POLY_FULL+-- | /ca_factor_zz_none/+-- +-- No integer factorization at all.+-- +ca_factor_zz_none = #const CA_FACTOR_ZZ_NONE+-- | /ca_factor_zz_smooth/+-- +-- Perform a smooth factorization to extract small prime factors+-- (heuristically up to ``CA_OPT_SMOOTH_LIMIT`` bits) in addition to+-- identifying perfect powers.+-- +ca_factor_zz_smooth = #const CA_FACTOR_ZZ_SMOOTH+-- | /ca_factor_zz_full/+-- +-- Perform a complete integer factorization into prime numbers.+-- This is prohibitively slow for general integers exceeding 70-80 digits.+ca_factor_zz_full = #const CA_FACTOR_ZZ_FULL++-- The following flags select the factorization to perform over+-- \(\mathbb{Z}\). Integer factorization is applied if /x/ is an element of+-- \(\mathbb{Q}\), and to the extracted rational content of polynomials.+-- Each flag in the list strictly encompasses the factorization power of+-- the preceding flag, so it is unnecessary to pass more than one flag.++-- Context options -------------------------------------------------------------++-- $context_options+-- The /options/ member of a @CaCtx@ object is an array of /slong/+-- values controlling simplification behavior and various other settings.+-- The values of the array at the following indices can be changed by the+-- user (example: @ctx->options[CA_OPT_PREC_LIMIT] = 65536@).+--+-- It is recommended to set options controlling evaluation only at the time+-- when a context object is created. Changing such options later should+-- normally be harmless, but since the update will not apply retroactively+-- to objects that have already been computed and cached, one might not see+-- the expected behavior. Superficial options (printing) can be changed at+-- any time.++type CaOption = CLong++ca_opt_verbose, ca_opt_print_flags, ca_opt_mpoly_ord, ca_opt_prec_limit, ca_opt_qqbar_deg_limit, ca_opt_low_prec, ca_opt_smooth_limit, ca_opt_lll_prec, ca_opt_pow_limit, ca_opt_use_groebner, ca_opt_groebner_length_limit, ca_opt_groebner_poly_length_limit, ca_opt_groebner_poly_bits_limit, ca_opt_vieta_limit, ca_opt_trig_form, ca_trig_direct, ca_trig_exponential, ca_trig_sine_cosine, ca_trig_tangent :: CaOption++-- | /ca_opt_verbose/+-- +-- Whether to print debug information. Default value: 0.+-- +ca_opt_verbose = #const CA_OPT_VERBOSE+-- | /ca_opt_print_flags/+-- +-- Printing style. See :ref:`ca-printing` for details.+-- Default value: ``CA_PRINT_DEFAULT``.+-- +ca_opt_print_flags = #const CA_OPT_PRINT_FLAGS+-- | /ca_opt_mpoly_ord/+-- +-- Monomial ordering to use for multivariate polynomials. Possible+-- values are ``ORD_LEX``, ``ORD_DEGLEX`` and ``ORD_DEGREVLEX``.+-- Default value: ``ORD_LEX``.+-- This option must be set before doing any computations.+-- +ca_opt_mpoly_ord = #const CA_OPT_MPOLY_ORD+-- | /ca_opt_prec_limit/+-- +-- Maximum precision to use internally for numerical evaluation with Arb,+-- and in some cases for the magntiude of exact coefficients.+-- This parameter affects the possibility to prove inequalities+-- and find simplifications between related extension numbers.+-- This is not a strict limit; some calculations may use higher precision+-- when there is a good reason to do so.+-- Default value: 4096.+-- +ca_opt_prec_limit = #const CA_OPT_PREC_LIMIT+-- | /ca_opt_qqbar_deg_limit/+-- +-- Maximum degree of :type:`qqbar_t` elements allowed internally during+-- simplification of algebraic numbers. This limit may be exceeded+-- when the user provides explicit :type:`qqbar_t` input of higher degree.+-- Default value: 120.+-- +ca_opt_qqbar_deg_limit = #const CA_OPT_QQBAR_DEG_LIMIT+-- | /ca_opt_low_prec/+-- +-- Numerical precision to use for fast checks (typically, before attempting+-- more expensive operations). Default value: 64.+-- +ca_opt_low_prec = #const CA_OPT_LOW_PREC+-- | /ca_opt_smooth_limit/+-- +-- Size in bits for factors in smooth integer factorization. Default value: 32.+-- +ca_opt_smooth_limit = #const CA_OPT_SMOOTH_LIMIT+-- | /ca_opt_lll_prec/+-- +-- Precision to use to find integer relations using LLL. Default value: 128.+-- +ca_opt_lll_prec = #const CA_OPT_LLL_PREC+-- | /ca_opt_pow_limit/+-- +-- Largest exponent to expand powers automatically. This only applies+-- in multivariate and transcendental fields: in number fields,+-- ``CA_OPT_PREC_LIMIT`` applies instead. Default value: 20.+-- +ca_opt_pow_limit = #const CA_OPT_POW_LIMIT+-- | /ca_opt_use_groebner/+-- +-- Boolean flag for whether to use Gröbner basis computation.+-- This flag and the following limits affect the ability to+-- prove multivariate identities.+-- Default value: 1.+-- +ca_opt_use_groebner = #const CA_OPT_USE_GROEBNER+-- | /ca_opt_groebner_length_limit/+-- +-- Maximum length of ideal basis allowed in Buchberger's algorithm.+-- Default value: 100.+-- +ca_opt_groebner_length_limit = #const CA_OPT_GROEBNER_LENGTH_LIMIT+-- | /ca_opt_groebner_poly_length_limit/+-- +-- Maximum length of polynomials allowed in Buchberger's algorithm.+-- Default value: 1000.+-- +ca_opt_groebner_poly_length_limit = #const CA_OPT_GROEBNER_POLY_LENGTH_LIMIT+-- | /ca_opt_groebner_poly_bits_limit/+-- +-- Maximum coefficient size in bits of polynomials allowed in+-- Buchberger's algorithm.+-- Default value: 10000.+-- +ca_opt_groebner_poly_bits_limit = #const CA_OPT_GROEBNER_POLY_BITS_LIMIT+-- | /ca_opt_vieta_limit/+-- +-- Maximum degree *n* of algebraic numbers for which to add Vieta's+-- formulas to the reduction ideal.+-- This must be set relatively low+-- since the number of terms in Vieta's formulas is `O(2^n)`+-- and the resulting Gröbner basis computations can be expensive.+-- Default value: 6.+-- +ca_opt_vieta_limit = #const CA_OPT_VIETA_LIMIT+-- | /ca_opt_trig_form/+-- +-- Default representation of trigonometric functions.+--+-- Default value: ``ca_trig_exponential``.+-- +-- The *exponential* representation is currently used by default+-- as typically works best for field arithmetic+-- and simplifications, although it has the disadvantage of+-- introducing complex numbers where real numbers would be sufficient.+-- This may change in the future.+--+-- The following values are possible:+ca_opt_trig_form = #const CA_OPT_TRIG_FORM+-- | /ca_trig_direct/+-- +-- Use the direct functions (with some exceptions).+-- +ca_trig_direct = #const CA_TRIG_DIRECT+-- | /ca_trig_exponential/+-- +-- Use complex exponentials.+-- +ca_trig_exponential = #const CA_TRIG_EXPONENTIAL+-- | /ca_trig_sine_cosine/+-- +-- Use sines and cosines.+-- +ca_trig_sine_cosine = #const CA_TRIG_SINE_COSINE+-- | /ca_trig_tangent/+-- +-- Use tangents.+-- +ca_trig_tangent = #const CA_TRIG_TANGENT++-- Internal representation -----------------------------------------------------++-- | /_ca_make_field_element/ /x/ /new_index/ /ctx/ +--+-- Changes the internal representation of /x/ to that of an element of the+-- field with index /new_index/ in the context object /ctx/. This may+-- destroy the value of /x/.+foreign import ccall "ca.h _ca_make_field_element"+  _ca_make_field_element :: Ptr CCa -> Ptr CCaField -> Ptr CCaCtx -> IO ()++-- | /_ca_make_fmpq/ /x/ /ctx/ +--+-- Changes the internal representation of /x/ to that of an element of the+-- trivial field \(\mathbb{Q}\). This may destroy the value of /x/.+foreign import ccall "ca.h _ca_make_fmpq"+  _ca_make_fmpq :: Ptr CCa -> Ptr CCaCtx -> IO ()++++

@@ -0,0 +1,33 @@+{-|+module      :  Data.Number.Flint.Calcium.Ca.Field+copyright   :  (c) 2023 Hartmut Monien+license     :  GNU GPL, version 2 or above (see LICENSE)+maintainer  :  hmonien@uni-bonn.de++A @CaFieldt@ represents the parent field \(K = \mathbb{Q}(a_1,\ldots,a_n)\)+of a @Ca@ element. A @CaField@ contains a list of pointers to+@CaExt@ objects as well as a reduction ideal.++The user does not normally need to create @CaField@ objects manually:+a @CaCtx@ context object manages a cache of fields automatically.++Internally, three types of field representation are used:++* The trivial field \(\mathbb{Q}\).++* An Antic number field \(\mathbb{Q}(a)\) where \(a\) is defined +  by a @QQbar@.++* A generic field \(\mathbb{Q}(a_1,\ldots,a_n)\) where \(n \ge 1\),+  and \(a_1\) is not defined by a @QQbar@ if \(n = 1\).++The field type mainly affects the internal storage of the field+elements; the distinction is mostly transparent to the external+interface.++-}+module Data.Number.Flint.Calcium.Ca.Field (+  module Data.Number.Flint.Calcium.Ca.Field.FFI+  ) where+  +import Data.Number.Flint.Calcium.Ca.Field.FFI

@@ -0,0 +1,176 @@+module Data.Number.Flint.Calcium.Ca.Field.FFI (+  -- * Extension fields+    CaField (..)+  , CCaField (..)+  -- * Memory management+  , ca_field_init_qq+  , ca_field_init_nf+  , ca_field_init_const+  , ca_field_init_fx+  , ca_field_init_fxy+  , ca_field_init_multi+  , ca_field_set_ext+  , ca_field_clear+  -- * Input and output+  , ca_field_print+  -- * Ideal+  , ca_field_build_ideal+  , ca_field_build_ideal_erf+  -- * Structure operations+  , ca_field_cmp+  -- * Cache+  , ca_field_cache_init+  , ca_field_cache_clear+  , ca_field_cache_insert_ext+) where ++-- Extension fields ------------------------------------------------------------++import Foreign.Ptr+import Foreign.ForeignPtr+import Foreign.C.Types++import Data.Number.Flint.NF.QQbar+import Data.Number.Flint.Calcium+import Data.Number.Flint.Calcium.Ca.Types++-- ca_field -------------------------------------------------------------------+  +-- Memory management -----------------------------------------------------------++-- | /ca_field_init_qq/ /K/ /ctx/ +--+-- Initializes /K/ to represent the trivial field \(\mathbb{Q}\).+foreign import ccall "ca_field.h ca_field_init_qq"+  ca_field_init_qq :: Ptr CCaField -> Ptr CCaCtx -> IO ()++-- | /ca_field_init_nf/ /K/ /x/ /ctx/ +--+-- Initializes /K/ to represent the algebraic number field+-- \(\mathbb{Q}(x)\).+foreign import ccall "ca_field.h ca_field_init_nf"+  ca_field_init_nf :: Ptr CCaField -> Ptr CQQbar -> Ptr CCaCtx -> IO ()++-- | /ca_field_init_const/ /K/ /func/ /ctx/ +--+-- Initializes /K/ to represent the field \(\mathbb{Q}(x)\) where /x/ is a+-- builtin constant defined by /func/ (example: /func/ = /CA_Pi/ for+-- \(x = \pi\)).+foreign import ccall "ca_field.h ca_field_init_const"+  ca_field_init_const :: Ptr CCaField -> CCalciumFunctionCode -> Ptr CCaCtx -> IO ()++-- | /ca_field_init_fx/ /K/ /func/ /x/ /ctx/ +--+-- Initializes /K/ to represent the field \(\mathbb{Q}(a)\) where+-- \(a = f(x)\), given a number /x/ and a builtin univariate function+-- /func/ (example: /func/ = /CA_Exp/ for \(e^x\)).+foreign import ccall "ca_field.h ca_field_init_fx"+  ca_field_init_fx :: Ptr CCaField -> CCalciumFunctionCode -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_field_init_fxy/ /K/ /func/ /x/ /y/ /ctx/ +--+-- Initializes /K/ to represent the field \(\mathbb{Q}(a,b)\) where+-- \(a = f(x, y)\).+foreign import ccall "ca_field.h ca_field_init_fxy"+  ca_field_init_fxy :: Ptr CCaField -> CCalciumFunctionCode -> Ptr CCa -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_field_init_multi/ /K/ /len/ /ctx/ +--+-- Initializes /K/ to represent a multivariate field+-- \(\mathbb{Q}(a_1, \ldots, a_n)\) in /n/ extension numbers. The extension+-- numbers must subsequently be assigned one by one using+-- @ca_field_set_ext@.+foreign import ccall "ca_field.h ca_field_init_multi"+  ca_field_init_multi :: Ptr CCaField -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_field_set_ext/ /K/ /i/ /x_index/ /ctx/ +--+-- Sets the extension number at position /i/ (here indexed from 0) of /K/+-- to the generator of the field with index /x_index/ in /ctx/. (It is+-- assumed that the generating field is a univariate field.)+-- +-- This only inserts a shallow reference: the field at index /x_index/ must+-- be kept alive until /K/ has been cleared.+foreign import ccall "ca_field.h ca_field_set_ext"+  ca_field_set_ext :: Ptr CCaField -> CLong -> Ptr CCaExt -> Ptr CCaCtx -> IO ()++-- | /ca_field_clear/ /K/ /ctx/ +--+-- Clears the field /K/. This does not clear the individual extension+-- numbers, which are only held as references.+foreign import ccall "ca_field.h ca_field_clear"+  ca_field_clear :: Ptr CCaField -> Ptr CCaCtx -> IO ()++foreign import ccall "ca_field.h &ca_field_clear"+  p_ca_field_clear :: FunPtr (Ptr CCaField -> Ptr CCaCtx -> IO ())++-- Input and output ------------------------------------------------------------++-- | /ca_field_print/ /K/ /ctx/ +--+-- Prints a description of the field /K/ to standard output.+foreign import ccall "ca_field.h ca_field_print"+  ca_field_print :: Ptr CCaField -> Ptr CCaCtx -> IO ()++-- Ideal -----------------------------------------------------------------------++-- | /ca_field_build_ideal/ /K/ /ctx/ +--+-- Given /K/ with assigned extension numbers, builds the reduction ideal+-- in-place.+foreign import ccall "ca_field.h ca_field_build_ideal"+  ca_field_build_ideal :: Ptr CCaField -> Ptr CCaCtx -> IO ()++-- | /ca_field_build_ideal_erf/ /K/ /ctx/ +--+-- Builds relations for error functions present among the extension numbers+-- in /K/. This heuristic adds relations that are consequences of the+-- functional equations+-- \(\operatorname{erf}(x) = -\operatorname{erf}(-x)\),+-- \(\operatorname{erfc}(x) = 1-\operatorname{erf}(x)\),+-- \(\operatorname{erfi}(x) = -i\operatorname{erf}(ix)\).+foreign import ccall "ca_field.h ca_field_build_ideal_erf"+  ca_field_build_ideal_erf :: Ptr CCaField -> Ptr CCaCtx -> IO ()++-- Structure operations --------------------------------------------------------++-- | /ca_field_cmp/ /K1/ /K2/ /ctx/ +--+-- Compares the field objects /K1/ and /K2/ in a canonical sort order,+-- returning -1, 0 or 1. This only performs a lexicographic comparison of+-- the representations of /K1/ and /K2/; the return value does not say+-- anything meaningful about the relative structures of /K1/ and /K2/ as+-- mathematical fields.+foreign import ccall "ca_field.h ca_field_cmp"+  ca_field_cmp :: Ptr CCaField -> Ptr CCaField -> Ptr CCaCtx -> IO CInt++-- Cache -----------------------------------------------------------------------++-- | /ca_field_cache_init/ /cache/ /ctx/ +--+-- Initializes /cache/ for use.+foreign import ccall "ca_field.h ca_field_cache_init"+  ca_field_cache_init :: Ptr CCaFieldCache -> Ptr CCaCtx -> IO ()++-- | /ca_field_cache_clear/ /cache/ /ctx/ +--+-- Clears /cache/, freeing the memory allocated internally. This does not+-- clear the individual extension numbers, which are only held as+-- references.+foreign import ccall "ca_field.h ca_field_cache_clear"+  ca_field_cache_clear :: Ptr CCaFieldCache -> Ptr CCaCtx -> IO ()++-- | /ca_field_cache_insert_ext/ /cache/ /x/ /len/ /ctx/ +--+-- Adds the field defined by the length-/len/ list of extension numbers /x/+-- to /cache/ without duplication. If such a field already exists in+-- /cache/, a pointer to that instance is returned. Otherwise, a field with+-- extension numbers /x/ is inserted into /cache/ and a pointer to that new+-- instance is returned. Upon insertion of a new field, the reduction ideal+-- is constructed via @ca_field_build_ideal@.+foreign import ccall "ca_field.h ca_field_cache_insert_ext"+  ca_field_cache_insert_ext :: Ptr CCaFieldCache -> Ptr (Ptr CCaExt) -> CLong -> Ptr CCaCtx -> IO (Ptr CCaField)++++

@@ -0,0 +1,21 @@+{-|+module      :  Data.Number.Flint.Calcium.Ca.Mat+copyright   :  (c) 2023 Hartmut Monien+license     :  GNU GPL, version 2 or above (see LICENSE)+maintainer  :  hmonien@uni-bonn.de+++-- A @CaMat@ represents a dense matrix over the real or complex numbers,+-- implemented as an array of entries of type @Ca@. The dimension+-- (number of rows and columns) of a matrix is fixed at initialization, and+-- the user must ensure that inputs and outputs to an operation have+-- compatible dimensions. The number of rows or columns in a matrix can be+-- zero.+--++-}+module Data.Number.Flint.Calcium.Ca.Mat (+  module Data.Number.Flint.Calcium.Ca.Mat.FFI+  ) where+  +import Data.Number.Flint.Calcium.Ca.Mat.FFI

@@ -0,0 +1,933 @@+module Data.Number.Flint.Calcium.Ca.Mat.FFI (+  -- * Matrices over the real and complex numbers+    CaMat (..)+  , CCaMat (..)+  , newCaMat+  , withCaMat+  , withNewCaMat+  -- * Types, macros and constants+  , ca_mat_entry+  , ca_mat_entry_ptr+  -- * Memory management+  , ca_mat_init+  , ca_mat_clear+  , ca_mat_swap+  , ca_mat_window_init+  , ca_mat_window_clear+  -- * Assignment and conversions+  , ca_mat_set+  , ca_mat_set_fmpz_mat+  , ca_mat_set_fmpq_mat+  , ca_mat_set_ca+  , ca_mat_transfer+  -- * Random generation+  , ca_mat_randtest+  , ca_mat_randtest_rational+  , ca_mat_randops+  -- * Input and output+  , ca_mat_get_str+  , ca_mat_fprint+  , ca_mat_print+  , ca_mat_printn+  -- * Special matrices+  , ca_mat_zero+  , ca_mat_one+  , ca_mat_ones+  , ca_mat_pascal+  , ca_mat_stirling+  , ca_mat_hilbert+  , ca_mat_dft+  -- * Comparisons and properties+  , ca_mat_check_equal+  , ca_mat_check_is_zero+  , ca_mat_check_is_one+  -- * Conjugate and transpose+  , ca_mat_transpose+  , ca_mat_conj+  , ca_mat_conj_transpose+  -- * Arithmetic+  , ca_mat_neg+  , ca_mat_add+  , ca_mat_sub+  , ca_mat_mul_classical+  , ca_mat_mul_same_nf+  , ca_mat_mul+  , ca_mat_mul_si+  , ca_mat_mul_fmpz+  , ca_mat_mul_fmpq+  , ca_mat_mul_ca+  , ca_mat_div_si+  , ca_mat_div_fmpz+  , ca_mat_div_fmpq+  , ca_mat_div_ca+  , ca_mat_add_ca+  , ca_mat_sub_ca+  , ca_mat_addmul_ca+  , ca_mat_submul_ca+  -- * Powers+  , ca_mat_sqr+  , ca_mat_pow_ui_binexp+  -- * Polynomial evaluation+  , _ca_mat_ca_poly_evaluate+  , ca_mat_ca_poly_evaluate+  -- * Gaussian elimination and LU decomposition+  , ca_mat_find_pivot+  , ca_mat_lu_classical+  , ca_mat_lu_recursive+  , ca_mat_lu+  , ca_mat_fflu+  , ca_mat_nonsingular_lu+  , ca_mat_nonsingular_fflu+  -- * Solving and inverse+  , ca_mat_inv+  , ca_mat_nonsingular_solve_adjugate+  , ca_mat_nonsingular_solve_fflu+  , ca_mat_nonsingular_solve_lu+  , ca_mat_nonsingular_solve+  , ca_mat_solve_tril_classical+  , ca_mat_solve_tril_recursive+  , ca_mat_solve_tril+  , ca_mat_solve_triu_classical+  , ca_mat_solve_triu_recursive+  , ca_mat_solve_triu+  , ca_mat_solve_fflu_precomp+  , ca_mat_solve_lu_precomp+  -- * Rank and echelon form+  , ca_mat_rank+  , ca_mat_rref_fflu+  , ca_mat_rref_lu+  , ca_mat_rref+  , ca_mat_right_kernel+  -- * Determinant and trace+  , ca_mat_trace+  , ca_mat_det_berkowitz+  , ca_mat_det_lu+  , ca_mat_det_bareiss+  , ca_mat_det_cofactor+  , ca_mat_det+  , ca_mat_adjugate_cofactor+  , ca_mat_adjugate_charpoly+  , ca_mat_adjugate+  -- * Characteristic polynomial+  , _ca_mat_charpoly_berkowitz+  , ca_mat_charpoly_berkowitz+  , _ca_mat_charpoly_danilevsky+  , ca_mat_charpoly_danilevsky+  , _ca_mat_charpoly+  , ca_mat_charpoly+  , ca_mat_companion+  -- * Eigenvalues and eigenvectors+  , ca_mat_eigenvalues+  , ca_mat_diagonalization+  -- * Jordan canonical form+  , ca_mat_jordan_blocks+  , ca_mat_set_jordan_blocks+  , ca_mat_jordan_transformation+  , ca_mat_jordan_form+  -- * Matrix functions+  , ca_mat_exp+  , ca_mat_log+) where++-- Matrices over the real and complex numbers ----------------------------------++import Foreign.Ptr+import Foreign.ForeignPtr+import Foreign.C.Types+import Foreign.C.String+import Foreign.Storable++import Data.Number.Flint.Flint+import Data.Number.Flint.Fmpz+import Data.Number.Flint.Fmpz.Mat+import Data.Number.Flint.Fmpq+import Data.Number.Flint.Fmpq.Mat+import Data.Number.Flint.Calcium+import Data.Number.Flint.Calcium.Ca+import Data.Number.Flint.Calcium.Ca.Types++#include <flint/ca_mat.h>++-- ca_mat_t --------------------------------------------------------------------++instance Storable CCaMat where+  {-# INLINE sizeOf #-}+  sizeOf _ = #{size ca_mat_t}+  {-# INLINE alignment #-}+  alignment _ = #{alignment ca_mat_t}+  peek ptr = CCaMat+    <$> #{peek ca_mat_struct, entries} ptr+    <*> #{peek ca_mat_struct, r      } ptr+    <*> #{peek ca_mat_struct, c      } ptr+    <*> #{peek ca_mat_struct, rows   } ptr+  poke = error "CCaMat.poke: Not defined."+ +newCaMat rows cols ctx@(CaCtx fctx) = do+  x <- mallocForeignPtr+  withForeignPtr x $ \xp -> do+    withCaCtx ctx $ \ctxp -> do+      ca_mat_init xp rows cols ctxp+    addForeignPtrFinalizerEnv p_ca_mat_clear xp fctx+  return $ CaMat x+  +{-# INLINE withCaMat #-}+withCaMat (CaMat x) f = do+  withForeignPtr x $ \px -> f px >>= return . (CaMat x,)++{-# INLINE withNewCaMat #-}+withNewCaMat rows cols ctx f = do+  x <- newCaMat rows cols ctx+  withCaMat x f+  +--------------------------------------------------------------------------------++-- | /ca_mat_entry_ptr/ /mat/ /i/ /j/ +--+-- Returns a pointer to the entry at row /i/ and column /j/. Equivalent to+-- @ca_mat_entry@ but implemented as a function.+foreign import ccall "ca_mat.h ca_mat_entry_ptr"+  ca_mat_entry_ptr :: Ptr CCaMat -> CLong -> CLong -> IO (Ptr CCa)++ca_mat_entry = ca_mat_entry_ptr++-- Memory management -----------------------------------------------------------++-- | /ca_mat_init/ /mat/ /r/ /c/ /ctx/ +--+-- Initializes the matrix, setting it to the zero matrix with /r/ rows and+-- /c/ columns.+foreign import ccall "ca_mat.h ca_mat_init"+  ca_mat_init :: Ptr CCaMat -> CLong -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_mat_clear/ /mat/ /ctx/ +--+-- Clears the matrix, deallocating all entries.+foreign import ccall "ca_mat.h ca_mat_clear"+  ca_mat_clear :: Ptr CCaMat -> Ptr CCaCtx -> IO ()++foreign import ccall "ca_mat.h &ca_mat_clear"+  p_ca_mat_clear :: FunPtr (Ptr CCaMat -> Ptr CCaCtx -> IO ())++-- | /ca_mat_swap/ /mat1/ /mat2/ /ctx/ +--+-- Efficiently swaps /mat1/ and /mat2/.+foreign import ccall "ca_mat.h ca_mat_swap"+  ca_mat_swap :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- | /ca_mat_window_init/ /window/ /mat/ /r1/ /c1/ /r2/ /c2/ /ctx/ +--+-- Initializes /window/ to a window matrix into the submatrix of /mat/+-- starting at the corner at row /r1/ and column /c1/ (inclusive) and+-- ending at row /r2/ and column /c2/ (exclusive).+foreign import ccall "ca_mat.h ca_mat_window_init"+  ca_mat_window_init :: Ptr CCaMat -> Ptr CCaMat -> CLong -> CLong -> CLong -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_mat_window_clear/ /window/ /ctx/ +--+-- Frees the window matrix.+foreign import ccall "ca_mat.h ca_mat_window_clear"+  ca_mat_window_clear :: Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- Assignment and conversions --------------------------------------------------++-- | /ca_mat_set/ /dest/ /src/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_set"+  ca_mat_set :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO ()+-- | /ca_mat_set_fmpz_mat/ /dest/ /src/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_set_fmpz_mat"+  ca_mat_set_fmpz_mat :: Ptr CCaMat -> Ptr CFmpzMat -> Ptr CCaCtx -> IO ()+-- | /ca_mat_set_fmpq_mat/ /dest/ /src/ /ctx/ +--+-- Sets /dest/ to /src/. The operands must have identical dimensions.+foreign import ccall "ca_mat.h ca_mat_set_fmpq_mat"+  ca_mat_set_fmpq_mat :: Ptr CCaMat -> Ptr CFmpqMat -> Ptr CCaCtx -> IO ()++-- | /ca_mat_set_ca/ /mat/ /c/ /ctx/ +--+-- Sets /mat/ to the matrix with the scalar /c/ on the main diagonal and+-- zeros elsewhere.+foreign import ccall "ca_mat.h ca_mat_set_ca"+  ca_mat_set_ca :: Ptr CCaMat -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_mat_transfer/ /res/ /res_ctx/ /src/ /src_ctx/ +--+-- Sets /res/ to /src/ where the corresponding context objects /res_ctx/+-- and /src_ctx/ may be different.+-- +-- This operation preserves the mathematical value represented by /src/,+-- but may result in a different internal representation depending on the+-- settings of the context objects.+foreign import ccall "ca_mat.h ca_mat_transfer"+  ca_mat_transfer :: Ptr CCaMat -> Ptr CCaCtx -> Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- Random generation -----------------------------------------------------------++-- | /ca_mat_randtest/ /mat/ /state/ /depth/ /bits/ /ctx/ +--+-- Sets /mat/ to a random matrix with entries having complexity up to+-- /depth/ and /bits/ (see @ca_randtest@).+foreign import ccall "ca_mat.h ca_mat_randtest"+  ca_mat_randtest :: Ptr CCaMat -> Ptr CFRandState -> CLong -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_mat_randtest_rational/ /mat/ /state/ /bits/ /ctx/ +--+-- Sets /mat/ to a random rational matrix with entries up to /bits/ bits in+-- size.+foreign import ccall "ca_mat.h ca_mat_randtest_rational"+  ca_mat_randtest_rational :: Ptr CCaMat -> Ptr CFRandState -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_mat_randops/ /mat/ /state/ /count/ /ctx/ +--+-- Randomizes /mat/ in-place by performing elementary row or column+-- operations. More precisely, at most count random additions or+-- subtractions of distinct rows and columns will be performed. This leaves+-- the rank (and for square matrices, the determinant) unchanged.+foreign import ccall "ca_mat.h ca_mat_randops"+  ca_mat_randops :: Ptr CCaMat -> Ptr CFRandState -> CLong -> Ptr CCaCtx -> IO ()++-- Input and output ------------------------------------------------------------++foreign import ccall "ca_mat.h ca_mat_get_str"+  ca_mat_get_str :: Ptr CCaMat -> Ptr CCaCtx -> IO CString++foreign import ccall "ca_mat.h ca_mat_fprint"+  ca_mat_fprint :: Ptr CFile -> Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- | /ca_mat_print/ /mat/ /ctx/ +--+-- Prints /mat/ to standard output. The entries are printed on separate+-- lines.+ca_mat_print :: Ptr CCaMat -> Ptr CCaCtx -> IO ()+ca_mat_print mat ctx = do+  printCStr (flip ca_mat_get_str ctx) mat+  return ()++-- | /ca_mat_printn/ /mat/ /digits/ /ctx/ +--+-- Prints a decimal representation of /mat/ with precision specified by+-- /digits/. The entries are comma-separated with square brackets and comma+-- separation for the rows.+foreign import ccall "ca_mat.h ca_mat_printn"+  ca_mat_printn :: Ptr CCaMat -> CLong -> Ptr CCaCtx -> IO ()++-- Special matrices ------------------------------------------------------------++-- | /ca_mat_zero/ /mat/ /ctx/ +--+-- Sets all entries in /mat/ to zero.+foreign import ccall "ca_mat.h ca_mat_zero"+  ca_mat_zero :: Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- | /ca_mat_one/ /mat/ /ctx/ +--+-- Sets the entries on the main diagonal of /mat/ to one, and all other+-- entries to zero.+foreign import ccall "ca_mat.h ca_mat_one"+  ca_mat_one :: Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- | /ca_mat_ones/ /mat/ /ctx/ +--+-- Sets all entries in /mat/ to one.+foreign import ccall "ca_mat.h ca_mat_ones"+  ca_mat_ones :: Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- | /ca_mat_pascal/ /mat/ /triangular/ /ctx/ +--+-- Sets /mat/ to a Pascal matrix, whose entries are binomial coefficients.+-- If /triangular/ is 0, constructs a full symmetric matrix with the rows+-- of Pascal\'s triangle as successive antidiagonals. If /triangular/ is 1,+-- constructs the upper triangular matrix with the rows of Pascal\'s+-- triangle as columns, and if /triangular/ is -1, constructs the lower+-- triangular matrix with the rows of Pascal\'s triangle as rows.+foreign import ccall "ca_mat.h ca_mat_pascal"+  ca_mat_pascal :: Ptr CCaMat -> CInt -> Ptr CCaCtx -> IO ()++-- | /ca_mat_stirling/ /mat/ /kind/ /ctx/ +--+-- Sets /mat/ to a Stirling matrix, whose entries are Stirling numbers. If+-- /kind/ is 0, the entries are set to the unsigned Stirling numbers of the+-- first kind. If /kind/ is 1, the entries are set to the signed Stirling+-- numbers of the first kind. If /kind/ is 2, the entries are set to the+-- Stirling numbers of the second kind.+foreign import ccall "ca_mat.h ca_mat_stirling"+  ca_mat_stirling :: Ptr CCaMat -> CInt -> Ptr CCaCtx -> IO ()++-- | /ca_mat_hilbert/ /mat/ /ctx/ +--+-- Sets /mat/ to the Hilbert matrix, which has entries+-- \(A_{i,j} = 1/(i+j+1)\).+foreign import ccall "ca_mat.h ca_mat_hilbert"+  ca_mat_hilbert :: Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- | /ca_mat_dft/ /mat/ /type/ /ctx/ +--+-- Sets /mat/ to the DFT (discrete Fourier transform) matrix of order /n/+-- where /n/ is the smallest dimension of /mat/ (if /mat/ is not square,+-- the matrix is extended periodically along the larger dimension). The+-- /type/ parameter selects between four different versions of the DFT+-- matrix (in which \(\omega = e^{2\pi i/n}\)):+-- +-- -   Type 0 -- entries \(A_{j,k} = \omega^{-jk}\)+-- -   Type 1 -- entries \(A_{j,k} = \omega^{jk} / n\)+-- -   Type 2 -- entries \(A_{j,k} = \omega^{-jk} / \sqrt{n}\)+-- -   Type 3 -- entries \(A_{j,k} = \omega^{jk} / \sqrt{n}\)+-- +-- The type 0 and 1 matrices are inverse pairs, and similarly for the type+-- 2 and 3 matrices.+foreign import ccall "ca_mat.h ca_mat_dft"+  ca_mat_dft :: Ptr CCaMat -> CInt -> Ptr CCaCtx -> IO ()++-- Comparisons and properties --------------------------------------------------++-- | /ca_mat_check_equal/ /A/ /B/ /ctx/ +--+-- Compares /A/ and /B/ for equality.+foreign import ccall "ca_mat.h ca_mat_check_equal"+  ca_mat_check_equal :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO (Ptr CTruth)++-- | /ca_mat_check_is_zero/ /A/ /ctx/ +--+-- Tests if /A/ is the zero matrix.+foreign import ccall "ca_mat.h ca_mat_check_is_zero"+  ca_mat_check_is_zero :: Ptr CCaMat -> Ptr CCaCtx -> IO (Ptr CTruth)++-- | /ca_mat_check_is_one/ /A/ /ctx/ +--+-- Tests if /A/ has ones on the main diagonal and zeros elsewhere.+foreign import ccall "ca_mat.h ca_mat_check_is_one"+  ca_mat_check_is_one :: Ptr CCaMat -> Ptr CCaCtx -> IO (Ptr CTruth)++-- Conjugate and transpose -----------------------------------------------------++-- | /ca_mat_transpose/ /res/ /A/ /ctx/ +--+-- Sets /res/ to the transpose of /A/.+foreign import ccall "ca_mat.h ca_mat_transpose"+  ca_mat_transpose :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- | /ca_mat_conj/ /res/ /A/ /ctx/ +--+-- Sets /res/ to the entrywise complex conjugate of /A/.+foreign import ccall "ca_mat.h ca_mat_conj"+  ca_mat_conj :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- | /ca_mat_conj_transpose/ /res/ /A/ /ctx/ +--+-- Sets /res/ to the conjugate transpose (Hermitian transpose) of /A/.+foreign import ccall "ca_mat.h ca_mat_conj_transpose"+  ca_mat_conj_transpose :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- Arithmetic ------------------------------------------------------------------++-- | /ca_mat_neg/ /res/ /A/ /ctx/ +--+-- Sets /res/ to the negation of /A/.+foreign import ccall "ca_mat.h ca_mat_neg"+  ca_mat_neg :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- | /ca_mat_add/ /res/ /A/ /B/ /ctx/ +--+-- Sets /res/ to the sum of /A/ and /B/.+foreign import ccall "ca_mat.h ca_mat_add"+  ca_mat_add :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- | /ca_mat_sub/ /res/ /A/ /B/ /ctx/ +--+-- Sets /res/ to the difference of /A/ and /B/.+foreign import ccall "ca_mat.h ca_mat_sub"+  ca_mat_sub :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- | /ca_mat_mul_classical/ /res/ /A/ /B/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_mul_classical"+  ca_mat_mul_classical :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO ()+-- | /ca_mat_mul_same_nf/ /res/ /A/ /B/ /K/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_mul_same_nf"+  ca_mat_mul_same_nf :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaMat -> Ptr CCaField -> Ptr CCaCtx -> IO ()+-- | /ca_mat_mul/ /res/ /A/ /B/ /ctx/ +--+-- Sets /res/ to the matrix product of /A/ and /B/. The /classical/ version+-- uses classical multiplication. The /same_nf/ version assumes (not+-- checked) that both /A/ and /B/ have coefficients in the same simple+-- algebraic number field /K/ or in \(\mathbb{Q}\). The default version+-- chooses an algorithm automatically.+foreign import ccall "ca_mat.h ca_mat_mul"+  ca_mat_mul :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- | /ca_mat_mul_si/ /B/ /A/ /c/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_mul_si"+  ca_mat_mul_si :: Ptr CCaMat -> Ptr CCaMat -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_mat_mul_fmpz/ /B/ /A/ /c/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_mul_fmpz"+  ca_mat_mul_fmpz :: Ptr CCaMat -> Ptr CCaMat -> Ptr CFmpz -> Ptr CCaCtx -> IO ()+-- | /ca_mat_mul_fmpq/ /B/ /A/ /c/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_mul_fmpq"+  ca_mat_mul_fmpq :: Ptr CCaMat -> Ptr CCaMat -> Ptr CFmpq -> Ptr CCaCtx -> IO ()+-- | /ca_mat_mul_ca/ /B/ /A/ /c/ /ctx/ +--+-- Sets /B/ to /A/ multiplied by the scalar /c/.+foreign import ccall "ca_mat.h ca_mat_mul_ca"+  ca_mat_mul_ca :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_mat_div_si/ /B/ /A/ /c/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_div_si"+  ca_mat_div_si :: Ptr CCaMat -> Ptr CCaMat -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_mat_div_fmpz/ /B/ /A/ /c/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_div_fmpz"+  ca_mat_div_fmpz :: Ptr CCaMat -> Ptr CCaMat -> Ptr CFmpz -> Ptr CCaCtx -> IO ()+-- | /ca_mat_div_fmpq/ /B/ /A/ /c/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_div_fmpq"+  ca_mat_div_fmpq :: Ptr CCaMat -> Ptr CCaMat -> Ptr CFmpq -> Ptr CCaCtx -> IO ()+-- | /ca_mat_div_ca/ /B/ /A/ /c/ /ctx/ +--+-- Sets /B/ to /A/ divided by the scalar /c/.+foreign import ccall "ca_mat.h ca_mat_div_ca"+  ca_mat_div_ca :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_mat_add_ca/ /B/ /A/ /c/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_add_ca"+  ca_mat_add_ca :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_mat_sub_ca/ /B/ /A/ /c/ /ctx/ +--+-- Sets /B/ to /A/ plus or minus the scalar /c/ (interpreted as a diagonal+-- matrix).+foreign import ccall "ca_mat.h ca_mat_sub_ca"+  ca_mat_sub_ca :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_mat_addmul_ca/ /B/ /A/ /c/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_addmul_ca"+  ca_mat_addmul_ca :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_mat_submul_ca/ /B/ /A/ /c/ /ctx/ +--+-- Sets the matrix /B/ to /B/ plus (or minus) the matrix /A/ multiplied by+-- the scalar /c/.+foreign import ccall "ca_mat.h ca_mat_submul_ca"+  ca_mat_submul_ca :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- Powers ----------------------------------------------------------------------++-- | /ca_mat_sqr/ /B/ /A/ /ctx/ +--+-- Sets /B/ to the square of /A/.+foreign import ccall "ca_mat.h ca_mat_sqr"+  ca_mat_sqr :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- | /ca_mat_pow_ui_binexp/ /B/ /A/ /exp/ /ctx/ +--+-- Sets /B/ to /A/ raised to the power /exp/, evaluated using binary+-- exponentiation.+foreign import ccall "ca_mat.h ca_mat_pow_ui_binexp"+  ca_mat_pow_ui_binexp :: Ptr CCaMat -> Ptr CCaMat -> CULong -> Ptr CCaCtx -> IO ()++-- Polynomial evaluation -------------------------------------------------------++-- | /_ca_mat_ca_poly_evaluate/ /res/ /poly/ /len/ /A/ /ctx/ +foreign import ccall "ca_mat.h _ca_mat_ca_poly_evaluate"+  _ca_mat_ca_poly_evaluate :: Ptr CCaMat -> Ptr CCa -> CLong -> Ptr CCaMat -> Ptr CCaCtx -> IO ()+-- | /ca_mat_ca_poly_evaluate/ /res/ /poly/ /A/ /ctx/ +--+-- Sets /res/ to \(f(A)\) where /f/ is the polynomial given by /poly/ and+-- /A/ is a square matrix. Uses the Paterson-Stockmeyer algorithm.+foreign import ccall "ca_mat.h ca_mat_ca_poly_evaluate"+  ca_mat_ca_poly_evaluate :: Ptr CCaMat -> Ptr CCaPoly -> Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- Gaussian elimination and LU decomposition -----------------------------------++-- | /ca_mat_find_pivot/ /pivot_row/ /mat/ /start_row/ /end_row/ /column/ /ctx/ +--+-- Attempts to find a nonzero entry in /mat/ with column index /column/ and+-- row index between /start_row/ (inclusive) and /end_row/ (exclusive).+-- +-- If the return value is @T_TRUE@, such an element exists, and /pivot_row/+-- is set to the row index. If the return value is @T_FALSE@, no such+-- element exists (all entries in this part of the column are zero). If the+-- return value is @T_UNKNOWN@, it is unknown whether such an element+-- exists (zero certification failed).+-- +-- This function is destructive: any elements that are nontrivially zero+-- but can be certified zero will be overwritten by exact zeros.+foreign import ccall "ca_mat.h ca_mat_find_pivot"+  ca_mat_find_pivot :: Ptr CLong -> Ptr CCaMat -> CLong -> CLong -> CLong -> Ptr CCaCtx -> IO (Ptr CTruth)++-- | /ca_mat_lu_classical/ /rank/ /P/ /LU/ /A/ /rank_check/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_lu_classical"+  ca_mat_lu_classical :: Ptr CLong -> Ptr CLong -> Ptr CCaMat -> Ptr CCaMat -> CInt -> Ptr CCaCtx -> IO CInt+-- | /ca_mat_lu_recursive/ /rank/ /P/ /LU/ /A/ /rank_check/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_lu_recursive"+  ca_mat_lu_recursive :: Ptr CLong -> Ptr CLong -> Ptr CCaMat -> Ptr CCaMat -> CInt -> Ptr CCaCtx -> IO CInt+-- | /ca_mat_lu/ /rank/ /P/ /LU/ /A/ /rank_check/ /ctx/ +--+-- Computes a generalized LU decomposition \(A = PLU\) of a given matrix+-- /A/, writing the rank of /A/ to /rank/.+-- +-- If /A/ is a nonsingular square matrix, /LU/ will be set to a unit+-- diagonal lower triangular matrix /L/ and an upper triangular matrix /U/+-- (the diagonal of /L/ will not be stored explicitly).+-- +-- If /A/ is an arbitrary matrix of rank /r/, /U/ will be in row echelon+-- form having /r/ nonzero rows, and /L/ will be lower triangular but+-- truncated to /r/ columns, having implicit ones on the /r/ first entries+-- of the main diagonal. All other entries will be zero.+-- +-- If a nonzero value for @rank_check@ is passed, the function will abandon+-- the output matrix in an undefined state and set the rank to 0 if /A/ is+-- detected to be rank-deficient.+-- +-- The algorithm can fail if it fails to certify that a pivot element is+-- zero or nonzero, in which case the correct rank cannot be determined.+-- The return value is 1 on success and 0 on failure. On failure, the data+-- in the output variables @rank@, @P@ and @LU@ will be meaningless.+-- +-- The /classical/ version uses iterative Gaussian elimination. The+-- /recursive/ version uses a block recursive algorithm to take advantage+-- of fast matrix multiplication.+foreign import ccall "ca_mat.h ca_mat_lu"+  ca_mat_lu :: Ptr CLong -> Ptr CLong -> Ptr CCaMat -> Ptr CCaMat -> CInt -> Ptr CCaCtx -> IO CInt++-- | /ca_mat_fflu/ /rank/ /P/ /LU/ /den/ /A/ /rank_check/ /ctx/ +--+-- Similar to @ca_mat_lu@, but computes a fraction-free LU decomposition+-- using the Bareiss algorithm. The denominator is written to /den/. Note+-- that despite being \"fraction-free\", this algorithm may introduce+-- fractions due to incomplete symbolic simplifications.+foreign import ccall "ca_mat.h ca_mat_fflu"+  ca_mat_fflu :: Ptr CLong -> Ptr CLong -> Ptr CCaMat -> Ptr CCa -> Ptr CCaMat -> CInt -> Ptr CCaCtx -> IO CInt++-- | /ca_mat_nonsingular_lu/ /P/ /LU/ /A/ /ctx/ +--+-- Wrapper for @ca_mat_lu@. If /A/ can be proved to be+-- invertible\/nonsingular, returns @T_TRUE@ and sets /P/ and /LU/ to a LU+-- decomposition \(A = PLU\). If /A/ can be proved to be singular, returns+-- @T_FALSE@. If /A/ cannot be proved to be either singular or nonsingular,+-- returns @T_UNKNOWN@. When the return value is @T_FALSE@ or @T_UNKNOWN@,+-- the LU factorization is not completed and the values of /P/ and /LU/ are+-- arbitrary.+foreign import ccall "ca_mat.h ca_mat_nonsingular_lu"+  ca_mat_nonsingular_lu :: Ptr CLong -> Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO (Ptr CTruth)++-- | /ca_mat_nonsingular_fflu/ /P/ /LU/ /den/ /A/ /ctx/ +--+-- Wrapper for @ca_mat_fflu@. Similar to @ca_mat_nonsingular_lu@, but+-- computes a fraction-free LU decomposition using the Bareiss algorithm.+-- The denominator is written to /den/. Note that despite being+-- \"fraction-free\", this algorithm may introduce fractions due to+-- incomplete symbolic simplifications.+foreign import ccall "ca_mat.h ca_mat_nonsingular_fflu"+  ca_mat_nonsingular_fflu :: Ptr CLong -> Ptr CCaMat -> Ptr CCa -> Ptr CCaMat -> Ptr CCaCtx -> IO (Ptr CTruth)++-- Solving and inverse ---------------------------------------------------------++-- | /ca_mat_inv/ /X/ /A/ /ctx/ +--+-- Determines if the square matrix /A/ is nonsingular, and if successful,+-- sets \(X = A^{-1}\) and returns @T_TRUE@. Returns @T_FALSE@ if /A/ is+-- singular, and @T_UNKNOWN@ if the rank of /A/ cannot be determined.+foreign import ccall "ca_mat.h ca_mat_inv"+  ca_mat_inv :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO (Ptr CTruth)++-- | /ca_mat_nonsingular_solve_adjugate/ /X/ /A/ /B/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_nonsingular_solve_adjugate"+  ca_mat_nonsingular_solve_adjugate :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO (Ptr CTruth)+-- | /ca_mat_nonsingular_solve_fflu/ /X/ /A/ /B/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_nonsingular_solve_fflu"+  ca_mat_nonsingular_solve_fflu :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO (Ptr CTruth)+-- | /ca_mat_nonsingular_solve_lu/ /X/ /A/ /B/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_nonsingular_solve_lu"+  ca_mat_nonsingular_solve_lu :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO (Ptr CTruth)+-- | /ca_mat_nonsingular_solve/ /X/ /A/ /B/ /ctx/ +--+-- Determines if the square matrix /A/ is nonsingular, and if successful,+-- solves \(AX = B\) and returns @T_TRUE@. Returns @T_FALSE@ if /A/ is+-- singular, and @T_UNKNOWN@ if the rank of /A/ cannot be determined.+foreign import ccall "ca_mat.h ca_mat_nonsingular_solve"+  ca_mat_nonsingular_solve :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO (Ptr CTruth)++-- | /ca_mat_solve_tril_classical/ /X/ /L/ /B/ /unit/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_solve_tril_classical"+  ca_mat_solve_tril_classical :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaMat -> CInt -> Ptr CCaCtx -> IO ()+-- | /ca_mat_solve_tril_recursive/ /X/ /L/ /B/ /unit/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_solve_tril_recursive"+  ca_mat_solve_tril_recursive :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaMat -> CInt -> Ptr CCaCtx -> IO ()+-- | /ca_mat_solve_tril/ /X/ /L/ /B/ /unit/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_solve_tril"+  ca_mat_solve_tril :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaMat -> CInt -> Ptr CCaCtx -> IO ()+-- | /ca_mat_solve_triu_classical/ /X/ /U/ /B/ /unit/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_solve_triu_classical"+  ca_mat_solve_triu_classical :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaMat -> CInt -> Ptr CCaCtx -> IO ()+-- | /ca_mat_solve_triu_recursive/ /X/ /U/ /B/ /unit/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_solve_triu_recursive"+  ca_mat_solve_triu_recursive :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaMat -> CInt -> Ptr CCaCtx -> IO ()+-- | /ca_mat_solve_triu/ /X/ /U/ /B/ /unit/ /ctx/ +--+-- Solves the lower triangular system \(LX = B\) or the upper triangular+-- system \(UX = B\), respectively. It is assumed (not checked) that the+-- diagonal entries are nonzero. If /unit/ is set, the main diagonal of /L/+-- or /U/ is taken to consist of all ones, and in that case the actual+-- entries on the diagonal are not read at all and can contain other data.+-- +-- The /classical/ versions perform the computations iteratively while the+-- /recursive/ versions perform the computations in a block recursive way+-- to benefit from fast matrix multiplication. The default versions choose+-- an algorithm automatically.+foreign import ccall "ca_mat.h ca_mat_solve_triu"+  ca_mat_solve_triu :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaMat -> CInt -> Ptr CCaCtx -> IO ()++-- | /ca_mat_solve_fflu_precomp/ /X/ /perm/ /A/ /den/ /B/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_solve_fflu_precomp"+  ca_mat_solve_fflu_precomp :: Ptr CCaMat -> Ptr CLong -> Ptr CCaMat -> Ptr CCa -> Ptr CCaMat -> Ptr CCaCtx -> IO ()+-- | /ca_mat_solve_lu_precomp/ /X/ /P/ /LU/ /B/ /ctx/ +--+-- Solves \(AX = B\) given the precomputed nonsingular LU decomposition+-- \(A = PLU\) or fraction-free LU decomposition with denominator /den/.+-- The matrices \(X\) and \(B\) are allowed to be aliased with each other,+-- but \(X\) is not allowed to be aliased with \(LU\).+foreign import ccall "ca_mat.h ca_mat_solve_lu_precomp"+  ca_mat_solve_lu_precomp :: Ptr CCaMat -> Ptr CLong -> Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- Rank and echelon form -------------------------------------------------------++-- | /ca_mat_rank/ /rank/ /A/ /ctx/ +--+-- Computes the rank of the matrix /A/. If successful, returns 1 and writes+-- the rank to @rank@. If unsuccessful, returns 0.+foreign import ccall "ca_mat.h ca_mat_rank"+  ca_mat_rank :: Ptr CLong -> Ptr CCaMat -> Ptr CCaCtx -> IO CInt++-- | /ca_mat_rref_fflu/ /rank/ /R/ /A/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_rref_fflu"+  ca_mat_rref_fflu :: Ptr CLong -> Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO CInt+-- | /ca_mat_rref_lu/ /rank/ /R/ /A/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_rref_lu"+  ca_mat_rref_lu :: Ptr CLong -> Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO CInt+-- | /ca_mat_rref/ /rank/ /R/ /A/ /ctx/ +--+-- Computes the reduced row echelon form (rref) of a given matrix. On+-- success, sets /R/ to the rref of /A/, writes the rank to /rank/, and+-- returns 1. On failure to certify the correct rank, returns 0, leaving+-- the data in /rank/ and /R/ meaningless.+-- +-- The /fflu/ version computes a fraction-free LU decomposition and then+-- converts the output ro rref form. The /lu/ version computes a regular LU+-- decomposition and then converts the output to rref form. The default+-- version uses an automatic algorithm choice and may implement additional+-- methods for special cases.+foreign import ccall "ca_mat.h ca_mat_rref"+  ca_mat_rref :: Ptr CLong -> Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO CInt++-- | /ca_mat_right_kernel/ /X/ /A/ /ctx/ +--+-- Sets /X/ to a basis of the right kernel (nullspace) of /A/. The output+-- matrix /X/ will be resized in-place to have a number of columns equal to+-- the nullity of /A/. Returns 1 on success. On failure, returns 0 and+-- leaves the data in /X/ meaningless.+foreign import ccall "ca_mat.h ca_mat_right_kernel"+  ca_mat_right_kernel :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO CInt++-- Determinant and trace -------------------------------------------------------++-- | /ca_mat_trace/ /trace/ /mat/ /ctx/ +--+-- Sets /trace/ to the sum of the entries on the main diagonal of /mat/.+foreign import ccall "ca_mat.h ca_mat_trace"+  ca_mat_trace :: Ptr CCa -> Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- | /ca_mat_det_berkowitz/ /det/ /A/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_det_berkowitz"+  ca_mat_det_berkowitz :: Ptr CCa -> Ptr CCaMat -> Ptr CCaCtx -> IO ()+-- | /ca_mat_det_lu/ /det/ /A/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_det_lu"+  ca_mat_det_lu :: Ptr CCa -> Ptr CCaMat -> Ptr CCaCtx -> IO CInt+-- | /ca_mat_det_bareiss/ /det/ /A/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_det_bareiss"+  ca_mat_det_bareiss :: Ptr CCa -> Ptr CCaMat -> Ptr CCaCtx -> IO CInt+-- | /ca_mat_det_cofactor/ /det/ /A/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_det_cofactor"+  ca_mat_det_cofactor :: Ptr CCa -> Ptr CCaMat -> Ptr CCaCtx -> IO ()+-- | /ca_mat_det/ /det/ /A/ /ctx/ +--+-- Sets /det/ to the determinant of the square matrix /A/. Various+-- algorithms are available:+-- +-- -   The /berkowitz/ version uses the division-free Berkowitz algorithm+--     performing \(O(n^4)\) operations. Since no zero tests are required,+--     it is guaranteed to succeed.+-- -   The /cofactor/ version performs cofactor expansion. This is+--     currently only supported for matrices up to size 4.+-- -   The /lu/ and /bareiss/ versions use rational LU decomposition and+--     fraction-free LU decomposition (Bareiss algorithm) respectively,+--     requiring \(O(n^3)\) operations. These algorithms can fail if zero+--     certification fails (see @ca_mat_nonsingular_lu@); they return 1 for+--     success and 0 for failure. Note that the Bareiss algorithm, despite+--     being \"fraction-free\", may introduce fractions due to incomplete+--     symbolic simplifications.+-- +-- The default function chooses an algorithm automatically. It will, in+-- addition, recognize trivially rational and integer matrices and evaluate+-- those determinants using @fmpq_mat_t@ or @fmpz_mat_t@.+-- +-- The various algorithms can produce different symbolic forms of the same+-- determinant. Which algorithm performs better depends strongly and+-- sometimes unpredictably on the structure of the matrix.+foreign import ccall "ca_mat.h ca_mat_det"+  ca_mat_det :: Ptr CCa -> Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- | /ca_mat_adjugate_cofactor/ /adj/ /det/ /A/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_adjugate_cofactor"+  ca_mat_adjugate_cofactor :: Ptr CCaMat -> Ptr CCa -> Ptr CCaMat -> Ptr CCaCtx -> IO ()+-- | /ca_mat_adjugate_charpoly/ /adj/ /det/ /A/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_adjugate_charpoly"+  ca_mat_adjugate_charpoly :: Ptr CCaMat -> Ptr CCa -> Ptr CCaMat -> Ptr CCaCtx -> IO ()+-- | /ca_mat_adjugate/ /adj/ /det/ /A/ /ctx/ +--+-- Sets /adj/ to the adjuate matrix of /A/ and /det/ to the determinant of+-- /A/, both computed simultaneously. The /cofactor/ version uses cofactor+-- expansion. The /charpoly/ version computes and evaluates the+-- characteristic polynomial. The default version uses an automatic+-- algorithm choice.+foreign import ccall "ca_mat.h ca_mat_adjugate"+  ca_mat_adjugate :: Ptr CCaMat -> Ptr CCa -> Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- Characteristic polynomial ---------------------------------------------------++-- | /_ca_mat_charpoly_berkowitz/ /cp/ /mat/ /ctx/ +foreign import ccall "ca_mat.h _ca_mat_charpoly_berkowitz"+  _ca_mat_charpoly_berkowitz :: Ptr CCa -> Ptr CCaMat -> Ptr CCaCtx -> IO ()+-- | /ca_mat_charpoly_berkowitz/ /cp/ /mat/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_charpoly_berkowitz"+  ca_mat_charpoly_berkowitz :: Ptr CCaPoly -> Ptr CCaMat -> Ptr CCaCtx -> IO ()+-- | /_ca_mat_charpoly_danilevsky/ /cp/ /mat/ /ctx/ +foreign import ccall "ca_mat.h _ca_mat_charpoly_danilevsky"+  _ca_mat_charpoly_danilevsky :: Ptr CCa -> Ptr CCaMat -> Ptr CCaCtx -> IO CInt+-- | /ca_mat_charpoly_danilevsky/ /cp/ /mat/ /ctx/ +foreign import ccall "ca_mat.h ca_mat_charpoly_danilevsky"+  ca_mat_charpoly_danilevsky :: Ptr CCaPoly -> Ptr CCaMat -> Ptr CCaCtx -> IO CInt+-- | /_ca_mat_charpoly/ /cp/ /mat/ /ctx/ +foreign import ccall "ca_mat.h _ca_mat_charpoly"+  _ca_mat_charpoly :: Ptr CCa -> Ptr CCaMat -> Ptr CCaCtx -> IO ()+-- | /ca_mat_charpoly/ /cp/ /mat/ /ctx/ +--+-- Sets /poly/ to the characteristic polynomial of /mat/ which must be a+-- square matrix. If the matrix has /n/ rows, the underscore method+-- requires space for \(n + 1\) output coefficients.+-- +-- The /berkowitz/ version uses a division-free algorithm requiring+-- \(O(n^4)\) operations. The /danilevsky/ version only performs \(O(n^3)\)+-- operations, but performs divisions and needs to check for zero which can+-- fail. This version returns 1 on success and 0 on failure. The default+-- version chooses an algorithm automatically.+foreign import ccall "ca_mat.h ca_mat_charpoly"+  ca_mat_charpoly :: Ptr CCaPoly -> Ptr CCaMat -> Ptr CCaCtx -> IO ()++-- | /ca_mat_companion/ /mat/ /poly/ /ctx/ +--+-- Sets /mat/ to the companion matrix of /poly/. This function verifies+-- that the leading coefficient of /poly/ is provably nonzero and that the+-- output matrix has the right size, returning 1 on success. It returns 0+-- if the leading coefficient of /poly/ cannot be proved nonzero or if the+-- size of the output matrix does not match.+foreign import ccall "ca_mat.h ca_mat_companion"+  ca_mat_companion :: Ptr CCaMat -> Ptr CCaPoly -> Ptr CCaCtx -> IO CInt++-- Eigenvalues and eigenvectors ------------------------------------------------++-- | /ca_mat_eigenvalues/ /lambda/ /exp/ /mat/ /ctx/ +--+-- Attempts to compute all complex eigenvalues of the given matrix /mat/.+-- On success, returns 1 and sets /lambda/ to the distinct eigenvalues with+-- corresponding multiplicities in /exp/. The eigenvalues are returned in+-- arbitrary order. On failure, returns 0 and leaves the values in /lambda/+-- and /exp/ arbitrary.+-- +-- This function effectively computes the characteristic polynomial and+-- then calls @ca_poly_roots@.+foreign import ccall "ca_mat.h ca_mat_eigenvalues"+  ca_mat_eigenvalues :: Ptr CCaVec -> Ptr CULong -> Ptr CCaMat -> Ptr CCaCtx -> IO CInt++-- | /ca_mat_diagonalization/ /D/ /P/ /A/ /ctx/ +--+-- Matrix diagonalization: attempts to compute a diagonal matrix /D/ and an+-- invertible matrix /P/ such that \(A = PDP^{-1}\). Returns @T_TRUE@ if+-- /A/ is diagonalizable and the computation succeeds, @T_FALSE@ if /A/ is+-- provably not diagonalizable, and @T_UNKNOWN@ if it is unknown whether+-- /A/ is diagonalizable. If the return value is not @T_TRUE@, the values+-- in /D/ and /P/ are arbitrary.+foreign import ccall "ca_mat.h ca_mat_diagonalization"+  ca_mat_diagonalization :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO (Ptr CTruth)++-- Jordan canonical form -------------------------------------------------------++-- | /ca_mat_jordan_blocks/ /lambda/ /num_blocks/ /block_lambda/ /block_size/ /A/ /ctx/ +--+-- Computes the blocks of the Jordan canonical form of /A/. On success,+-- returns 1 and sets /lambda/ to the unique eigenvalues of /A/, sets+-- /num_blocks/ to the number of Jordan blocks, entry /i/ of /block_lambda/+-- to the index of the eigenvalue in Jordan block /i/, and entry /i/ of+-- /block_size/ to the size of Jordan block /i/. On failure, returns 0,+-- leaving arbitrary values in the output variables. The user should+-- allocate space in /block_lambda/ and /block_size/ for up to /n/ entries+-- where /n/ is the size of the matrix.+-- +-- The Jordan form is unique up to the ordering of blocks, which is+-- arbitrary.+foreign import ccall "ca_mat.h ca_mat_jordan_blocks"+  ca_mat_jordan_blocks :: Ptr CCaVec -> Ptr CLong -> Ptr CLong -> Ptr CLong -> Ptr CCaMat -> Ptr CCaCtx -> IO CInt++-- | /ca_mat_set_jordan_blocks/ /mat/ /lambda/ /num_blocks/ /block_lambda/ /block_size/ /ctx/ +--+-- Sets /mat/ to the concatenation of the Jordan blocks given in /lambda/,+-- /num_blocks/, /block_lambda/ and /block_size/. See+-- @ca_mat_jordan_blocks@ for an explanation of these variables.+foreign import ccall "ca_mat.h ca_mat_set_jordan_blocks"+  ca_mat_set_jordan_blocks :: Ptr CCaMat -> Ptr CCaVec -> CLong -> Ptr CLong -> Ptr CLong -> Ptr CCaCtx -> IO ()++-- | /ca_mat_jordan_transformation/ /mat/ /lambda/ /num_blocks/ /block_lambda/ /block_size/ /A/ /ctx/ +--+-- Given the precomputed Jordan block decomposition (/lambda/,+-- /num_blocks/, /block_lambda/, /block_size/) of the square matrix /A/,+-- computes the corresponding transformation matrix /P/ such that+-- \(A = P J P^{-1}\). On success, writes /P/ to /mat/ and returns 1. On+-- failure, returns 0, leaving the value of /mat/ arbitrary.+foreign import ccall "ca_mat.h ca_mat_jordan_transformation"+  ca_mat_jordan_transformation :: Ptr CCaMat -> Ptr CCaVec -> CLong -> Ptr CLong -> Ptr CLong -> Ptr CCaMat -> Ptr CCaCtx -> IO CInt++-- | /ca_mat_jordan_form/ /J/ /P/ /A/ /ctx/ +--+-- Computes the Jordan decomposition \(A = P J P^{-1}\) of the given square+-- matrix /A/. The user can pass /NULL/ for the output variable /P/, in+-- which case only /J/ is computed. On success, returns 1. On failure,+-- returns 0, leaving the values of /J/ and /P/ arbitrary.+-- +-- This function is a convenience wrapper around @ca_mat_jordan_blocks@,+-- @ca_mat_set_jordan_blocks@ and @ca_mat_jordan_transformation@. For+-- computations with the Jordan decomposition, it is often better to use+-- those methods directly since they give direct access to the spectrum and+-- block structure.+foreign import ccall "ca_mat.h ca_mat_jordan_form"+  ca_mat_jordan_form :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO CInt++-- Matrix functions ------------------------------------------------------------++-- | /ca_mat_exp/ /res/ /A/ /ctx/ +--+-- Matrix exponential: given a square matrix /A/, sets /res/ to \(e^A\) and+-- returns 1 on success. If unsuccessful, returns 0, leaving the values in+-- /res/ arbitrary.+-- +-- This function uses Jordan decomposition. The matrix exponential always+-- exists, but computation can fail if computing the Jordan decomposition+-- fails.+foreign import ccall "ca_mat.h ca_mat_exp"+  ca_mat_exp :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO CInt++-- | /ca_mat_log/ /res/ /A/ /ctx/ +--+-- Matrix logarithm: given a square matrix /A/, sets /res/ to a logarithm+-- \(\log(A)\) and returns @T_TRUE@ on success. If /A/ can be proved to+-- have no logarithm, returns @T_FALSE@. If the existence of a logarithm+-- cannot be proved, returns @T_UNKNOWN@.+-- +-- This function uses the Jordan decomposition, and the branch of the+-- matrix logarithm is defined by taking the principal values of the+-- logarithms of all eigenvalues.+foreign import ccall "ca_mat.h ca_mat_log"+  ca_mat_log :: Ptr CCaMat -> Ptr CCaMat -> Ptr CCaCtx -> IO (Ptr CTruth)+

@@ -0,0 +1,11 @@+{-|+module      :  Data.Number.Flint.Calcium.Ca.Poly+copyright   :  (c) 2023 Hartmut Monien+license     :  GNU GPL, version 2 or above (see LICENSE)+maintainer  :  hmonien@uni-bonn.de+-}+module Data.Number.Flint.Calcium.Ca.Poly (+  module Data.Number.Flint.Calcium.Ca.Poly.FFI+  ) where+  +import Data.Number.Flint.Calcium.Ca.Poly.FFI

@@ -0,0 +1,728 @@+module Data.Number.Flint.Calcium.Ca.Poly.FFI (+  -- * Dense univariate polynomials over the real and complex numbers+    CaPoly (..)+  , CCaPoly (..)+  , newCaPoly+  , withCaPoly+  , withNewCaPoly+  -- * Memory management+  , ca_poly_init+  , ca_poly_clear+  , ca_poly_fit_length+  , _ca_poly_set_length+  , _ca_poly_normalise+  -- * Assignment and simple values+  , ca_poly_zero+  , ca_poly_one+  , ca_poly_x+  , ca_poly_set_ca+  , ca_poly_set_si+  , ca_poly_set+  , ca_poly_set_fmpz_poly+  , ca_poly_set_fmpq_poly+  , ca_poly_set_coeff_ca+  , ca_poly_transfer+  -- * Random generation+  , ca_poly_randtest+  , ca_poly_randtest_rational+  -- * Input and output+  , ca_poly_get_str+  , ca_poly_fprint+  , ca_poly_print+  , ca_poly_printn+  -- * Degree and leading coefficient+  , ca_poly_is_proper+  , ca_poly_make_monic+  , _ca_poly_reverse+  , ca_poly_reverse+  -- * Comparisons+  , _ca_poly_check_equal+  , ca_poly_check_equal+  , ca_poly_check_is_zero+  , ca_poly_check_is_one+  -- * Arithmetic+  , _ca_poly_shift_left+  , ca_poly_shift_left+  , _ca_poly_shift_right+  , ca_poly_shift_right+  , ca_poly_neg+  , _ca_poly_add+  , ca_poly_add+  , _ca_poly_sub+  , ca_poly_sub+  , _ca_poly_mul+  , ca_poly_mul+  , _ca_poly_mullow+  , ca_poly_mullow+  , ca_poly_mul_ca+  , ca_poly_div_ca+  , _ca_poly_divrem_basecase+  , ca_poly_divrem_basecase+  , _ca_poly_divrem+  , ca_poly_divrem+  , ca_poly_div+  , ca_poly_rem+  , _ca_poly_pow_ui_trunc+  , ca_poly_pow_ui_trunc+  , _ca_poly_pow_ui+  , ca_poly_pow_ui+  -- * Evaluation and composition+  , _ca_poly_evaluate_horner+  , ca_poly_evaluate_horner+  , _ca_poly_evaluate+  , ca_poly_evaluate+  , _ca_poly_compose+  , ca_poly_compose+  -- * Derivative and integral+  , _ca_poly_derivative+  , ca_poly_derivative+  , _ca_poly_integral+  , ca_poly_integral+  -- * Power series division+  , _ca_poly_inv_series+  , ca_poly_inv_series+  , _ca_poly_div_series+  , ca_poly_div_series+  -- * Elementary functions+  , _ca_poly_exp_series+  , ca_poly_exp_series+  , _ca_poly_log_series+  , ca_poly_log_series+  -- * Greatest common divisor+  , _ca_poly_gcd_euclidean+  , ca_poly_gcd_euclidean+  , _ca_poly_gcd+  , ca_poly_gcd+  -- * Roots and factorization+  , ca_poly_factor_squarefree+  , ca_poly_squarefree_part+  , _ca_poly_set_roots+  , ca_poly_set_roots+  , _ca_poly_roots+  , ca_poly_roots+  -- * Vectors of polynomials+  , _ca_poly_vec_init+  , ca_poly_vec_init+  , _ca_poly_vec_fit_length+  , ca_poly_vec_set_length+  , _ca_poly_vec_clear+  , ca_poly_vec_clear+  , ca_poly_vec_append+) where++-- Dense univariate polynomials over the real and complex number ---------------++import Foreign.Ptr+import Foreign.ForeignPtr+import Foreign.C.Types+import Foreign.C.String+import Foreign.Storable++import Data.Number.Flint.Flint+import Data.Number.Flint.Fmpz.Poly+import Data.Number.Flint.Fmpq.Poly+import Data.Number.Flint.Calcium+import Data.Number.Flint.Calcium.Ca.Types+import Data.Number.Flint.Calcium.Ca++#include <flint/ca_poly.h>++-- ca_poly_t -------------------------------------------------------------------++instance Storable CCaPoly where+  {-# INLINE sizeOf #-}+  sizeOf _ = #{size ca_poly_t}+  {-# INLINE alignment #-}+  alignment _ = #{alignment ca_poly_t}+  peek = error "CCaPoly.peek: Not defined"+  poke = error "CCaPoly.poke: Not defined"++newCaPoly ctx@(CaCtx fctx) = do+  x <- mallocForeignPtr+  withForeignPtr x $ \xp -> do+    withCaCtx ctx $ \ctxp -> do+      ca_poly_init xp ctxp+    addForeignPtrFinalizerEnv p_ca_poly_clear xp fctx+  return $ CaPoly x++{-# INLINE withCaPoly #-}+withCaPoly (CaPoly x) f = do+  withForeignPtr x $ \xp -> f xp >>= return . (CaPoly x,)++withNewCaPoly ctx f = do+  x <- newCaPoly ctx+  withCaPoly x f++-- A @CaPoly@ represents a univariate polynomial over the real or+-- complex numbers (an element of \(\mathbb{R}[X]\) or \(\mathbb{C}[X]\)),+-- implemented as an array of coefficients of type @ca_struct@.+--+-- Most functions are provided in two versions: an underscore method which+-- operates directly on pre-allocated arrays of coefficients and generally+-- has some restrictions (such as requiring the lengths to be nonzero and+-- not supporting aliasing of the input and output arrays), and a+-- non-underscore method which performs automatic memory management and+-- handles degenerate cases.+--+-- Warnings:+--++++-- A polynomial with numerical coefficients and with a nonzero leading+-- coefficient is called /proper/. The function @ca_poly_is_proper@ can be+-- used to check for violations.+--+-- Types, macros and constants -------------------------------------------------++++++++-- Memory management -----------------------------------------------------------++-- | /ca_poly_init/ /poly/ /ctx/ +--+-- Initializes the polynomial for use, setting it to the zero polynomial.+foreign import ccall "ca_poly.h ca_poly_init"+  ca_poly_init :: Ptr CCaPoly -> Ptr CCaCtx -> IO ()++-- | /ca_poly_clear/ /poly/ /ctx/ +--+-- Clears the polynomial, deallocating all coefficients and the coefficient+-- array.+foreign import ccall "ca_poly.h ca_poly_clear"+  ca_poly_clear :: Ptr CCaPoly -> Ptr CCaCtx -> IO ()++foreign import ccall "ca_poly.h &ca_poly_clear"+  p_ca_poly_clear :: FunPtr (Ptr CCaPoly -> Ptr CCaCtx -> IO ())++-- | /ca_poly_fit_length/ /poly/ /len/ /ctx/ +--+-- Makes sure that the coefficient array of the polynomial contains at+-- least /len/ initialized coefficients.+foreign import ccall "ca_poly.h ca_poly_fit_length"+  ca_poly_fit_length :: Ptr CCaPoly -> CLong -> Ptr CCaCtx -> IO ()++-- | /_ca_poly_set_length/ /poly/ /len/ /ctx/ +--+-- Directly changes the length of the polynomial, without allocating or+-- deallocating coefficients. The value should not exceed the allocation+-- length.+foreign import ccall "ca_poly.h _ca_poly_set_length"+  _ca_poly_set_length :: Ptr CCaPoly -> CLong -> Ptr CCaCtx -> IO ()++-- | /_ca_poly_normalise/ /poly/ /ctx/ +--+-- Strips any top coefficients which can be proved identical to zero.+foreign import ccall "ca_poly.h _ca_poly_normalise"+  _ca_poly_normalise :: Ptr CCaPoly -> Ptr CCaCtx -> IO ()++-- Assignment and simple values ------------------------------------------------++-- | /ca_poly_zero/ /poly/ /ctx/ +--+-- Sets /poly/ to the zero polynomial.+foreign import ccall "ca_poly.h ca_poly_zero"+  ca_poly_zero :: Ptr CCaPoly -> Ptr CCaCtx -> IO ()++-- | /ca_poly_one/ /poly/ /ctx/ +--+-- Sets /poly/ to the constant polynomial 1.+foreign import ccall "ca_poly.h ca_poly_one"+  ca_poly_one :: Ptr CCaPoly -> Ptr CCaCtx -> IO ()++-- | /ca_poly_x/ /poly/ /ctx/ +--+-- Sets /poly/ to the monomial /x/.+foreign import ccall "ca_poly.h ca_poly_x"+  ca_poly_x :: Ptr CCaPoly -> Ptr CCaCtx -> IO ()++-- | /ca_poly_set_ca/ /poly/ /c/ /ctx/ +foreign import ccall "ca_poly.h ca_poly_set_ca"+  ca_poly_set_ca :: Ptr CCaPoly -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_poly_set_si/ /poly/ /c/ /ctx/ +--+-- Sets /poly/ to the constant polynomial /c/.+foreign import ccall "ca_poly.h ca_poly_set_si"+  ca_poly_set_si :: Ptr CCaPoly -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_poly_set/ /res/ /src/ /ctx/ +foreign import ccall "ca_poly.h ca_poly_set"+  ca_poly_set :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaCtx -> IO ()+  +-- | /ca_poly_set_fmpz_poly/ /res/ /src/ /ctx/ +foreign import ccall "ca_poly.h ca_poly_set_fmpz_poly"+  ca_poly_set_fmpz_poly :: Ptr CCaPoly -> Ptr CFmpzPoly -> Ptr CCaCtx -> IO ()+-- | /ca_poly_set_fmpq_poly/ /res/ /src/ /ctx/ +--+-- Sets /poly/ the polynomial /src/.+foreign import ccall "ca_poly.h ca_poly_set_fmpq_poly"+  ca_poly_set_fmpq_poly :: Ptr CCaPoly -> Ptr CFmpqPoly -> Ptr CCaCtx -> IO ()++-- | /ca_poly_set_coeff_ca/ /poly/ /n/ /x/ /ctx/ +--+-- Sets the coefficient at position /n/ in /poly/ to /x/.+foreign import ccall "ca_poly.h ca_poly_set_coeff_ca"+  ca_poly_set_coeff_ca :: Ptr CCaPoly -> CLong -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_poly_transfer/ /res/ /res_ctx/ /src/ /src_ctx/ +--+-- Sets /res/ to /src/ where the corresponding context objects /res_ctx/+-- and /src_ctx/ may be different.+-- +-- This operation preserves the mathematical value represented by /src/,+-- but may result in a different internal representation depending on the+-- settings of the context objects.+foreign import ccall "ca_poly.h ca_poly_transfer"+  ca_poly_transfer :: Ptr CCaPoly -> Ptr CCaCtx -> Ptr CCaPoly -> Ptr CCaCtx -> IO ()++-- Random generation -----------------------------------------------------------++-- | /ca_poly_randtest/ /poly/ /state/ /len/ /depth/ /bits/ /ctx/ +--+-- Sets /poly/ to a random polynomial of length up to /len/ and with+-- entries having complexity up to /depth/ and /bits/ (see @ca_randtest@).+foreign import ccall "ca_poly.h ca_poly_randtest"+  ca_poly_randtest :: Ptr CCaPoly -> Ptr CFRandState -> CLong -> CLong -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_poly_randtest_rational/ /poly/ /state/ /len/ /bits/ /ctx/ +--+-- Sets /poly/ to a random rational polynomial of length up to /len/ and+-- with entries up to /bits/ bits in size.+foreign import ccall "ca_poly.h ca_poly_randtest_rational"+  ca_poly_randtest_rational :: Ptr CCaPoly -> Ptr CFRandState -> CLong -> CLong -> Ptr CCaCtx -> IO ()++-- Input and output ------------------------------------------------------------++-- | /ca_poly_get_str/ /poly/ /ctx/ +--+-- Returns a string representation of /poly/. The coefficients are printed on+-- separate lines.+foreign import ccall "ca_poly.h ca_poly_get_str"+  ca_poly_get_str :: Ptr CCaPoly -> Ptr CCaCtx -> IO CString++-- | /ca_poly_fprint/ /file/ /poly/ /ctx/ +--+-- Prints /poly/ to file. The coefficients are printed on+-- separate lines.+foreign import ccall "ca_poly.h ca_poly_fprint"+  ca_poly_fprint :: Ptr CFile -> Ptr CCaPoly -> Ptr CCaCtx -> IO ()++-- | /ca_poly_print/ /poly/ /ctx/ +--+-- Prints /poly/ to standard output. The coefficients are printed on+-- separate lines.+ca_poly_print :: Ptr CCaPoly -> Ptr CCaCtx -> IO ()+ca_poly_print poly ctx = do+  printCStr (\poly -> ca_poly_get_str poly ctx) poly+  return ()+  +-- | /ca_poly_printn/ /poly/ /digits/ /ctx/ +--+-- Prints a decimal representation of /poly/ with precision specified by+-- /digits/. The coefficients are comma-separated and the whole list is+-- enclosed in square brackets.+foreign import ccall "ca_poly.h ca_poly_printn"+  ca_poly_printn :: Ptr CCaPoly -> CLong -> Ptr CCaCtx -> IO ()++-- Degree and leading coefficient ----------------------------------------------++-- | /ca_poly_is_proper/ /poly/ /ctx/ +--+-- Checks that /poly/ represents an element of \(\mathbb{C}[X]\) with+-- well-defined degree. This returns 1 if the leading coefficient of /poly/+-- is nonzero and all coefficients of /poly/ are numbers (not special+-- values). It returns 0 otherwise. It returns 1 when /poly/ is precisely+-- the zero polynomial (which does not have a leading coefficient).+foreign import ccall "ca_poly.h ca_poly_is_proper"+  ca_poly_is_proper :: Ptr CCaPoly -> Ptr CCaCtx -> IO CInt++-- | /ca_poly_make_monic/ /res/ /poly/ /ctx/ +--+-- Makes /poly/ monic by dividing by the leading coefficient if possible+-- and returns 1. Returns 0 if the leading coefficient cannot be certified+-- to be nonzero, or if /poly/ is the zero polynomial.+foreign import ccall "ca_poly.h ca_poly_make_monic"+  ca_poly_make_monic :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaCtx -> IO CInt++-- | /_ca_poly_reverse/ /res/ /poly/ /len/ /n/ /ctx/ +--+foreign import ccall "ca_poly.h _ca_poly_reverse"+  _ca_poly_reverse :: Ptr CCa -> Ptr CCa -> CLong -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_poly_reverse/ /res/ /poly/ /n/ /ctx/ +--+-- Sets /res/ to the reversal of /poly/ considered as a polynomial of+-- length /n/, zero-padding if needed. The underscore method assumes that+-- /len/ is positive and less than or equal to /n/.+foreign import ccall "ca_poly.h ca_poly_reverse"+  ca_poly_reverse :: Ptr CCaPoly -> Ptr CCaPoly -> CLong -> Ptr CCaCtx -> IO ()++-- Comparisons -----------------------------------------------------------------++-- | /_ca_poly_check_equal/ /poly1/ /len1/ /poly2/ /len2/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_check_equal"+  _ca_poly_check_equal :: Ptr CCa -> CLong -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO (Ptr CTruth)+-- | /ca_poly_check_equal/ /poly1/ /poly2/ /ctx/ +--+-- Checks if /poly1/ and /poly2/ represent the same polynomial. The+-- underscore method assumes that /len1/ is at least as large as /len2/.+foreign import ccall "ca_poly.h ca_poly_check_equal"+  ca_poly_check_equal :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaCtx -> IO (Ptr CTruth)++-- | /ca_poly_check_is_zero/ /poly/ /ctx/ +--+-- Checks if /poly/ is the zero polynomial.+foreign import ccall "ca_poly.h ca_poly_check_is_zero"+  ca_poly_check_is_zero :: Ptr CCaPoly -> Ptr CCaCtx -> IO (Ptr CTruth)++-- | /ca_poly_check_is_one/ /poly/ /ctx/ +--+-- Checks if /poly/ is the constant polynomial 1.+foreign import ccall "ca_poly.h ca_poly_check_is_one"+  ca_poly_check_is_one :: Ptr CCaPoly -> Ptr CCaCtx -> IO (Ptr CTruth)++-- Arithmetic ------------------------------------------------------------------++-- | /_ca_poly_shift_left/ /res/ /poly/ /len/ /n/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_shift_left"+  _ca_poly_shift_left :: Ptr CCa -> Ptr CCa -> CLong -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_poly_shift_left/ /res/ /poly/ /n/ /ctx/ +--+-- Sets /res/ to /poly/ shifted /n/ coefficients to the left; that is,+-- multiplied by \(x^n\).+foreign import ccall "ca_poly.h ca_poly_shift_left"+  ca_poly_shift_left :: Ptr CCaPoly -> Ptr CCaPoly -> CLong -> Ptr CCaCtx -> IO ()++-- | /_ca_poly_shift_right/ /res/ /poly/ /len/ /n/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_shift_right"+  _ca_poly_shift_right :: Ptr CCa -> Ptr CCa -> CLong -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_poly_shift_right/ /res/ /poly/ /n/ /ctx/ +--+-- Sets /res/ to /poly/ shifted /n/ coefficients to the right; that is,+-- divided by \(x^n\).+foreign import ccall "ca_poly.h ca_poly_shift_right"+  ca_poly_shift_right :: Ptr CCaPoly -> Ptr CCaPoly -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_poly_neg/ /res/ /src/ /ctx/ +--+-- Sets /res/ to the negation of /src/.+foreign import ccall "ca_poly.h ca_poly_neg"+  ca_poly_neg :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaCtx -> IO ()++-- | /_ca_poly_add/ /res/ /poly1/ /len1/ /poly2/ /len2/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_add"+  _ca_poly_add :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_poly_add/ /res/ /poly1/ /poly2/ /ctx/ +--+-- Sets /res/ to the sum of /poly1/ and /poly2/.+foreign import ccall "ca_poly.h ca_poly_add"+  ca_poly_add :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaCtx -> IO ()++-- | /_ca_poly_sub/ /res/ /poly1/ /len1/ /poly2/ /len2/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_sub"+  _ca_poly_sub :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_poly_sub/ /res/ /poly1/ /poly2/ /ctx/ +--+-- Sets /res/ to the difference of /poly1/ and /poly2/.+foreign import ccall "ca_poly.h ca_poly_sub"+  ca_poly_sub :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaCtx -> IO ()++-- | /_ca_poly_mul/ /res/ /poly1/ /len1/ /poly2/ /len2/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_mul"+  _ca_poly_mul :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_poly_mul/ /res/ /poly1/ /poly2/ /ctx/ +--+-- Sets /res/ to the product of /poly1/ and /poly2/.+foreign import ccall "ca_poly.h ca_poly_mul"+  ca_poly_mul :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaCtx -> IO ()++-- | /_ca_poly_mullow/ /C/ /poly1/ /len1/ /poly2/ /len2/ /n/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_mullow"+  _ca_poly_mullow :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCa -> CLong -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_poly_mullow/ /res/ /poly1/ /poly2/ /n/ /ctx/ +--+-- Sets /res/ to the product of /poly1/ and /poly2/ truncated to length+-- /n/.+foreign import ccall "ca_poly.h ca_poly_mullow"+  ca_poly_mullow :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaPoly -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_poly_mul_ca/ /res/ /poly/ /c/ /ctx/ +--+-- Sets /res/ to /poly/ multiplied by the scalar /c/.+foreign import ccall "ca_poly.h ca_poly_mul_ca"+  ca_poly_mul_ca :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /ca_poly_div_ca/ /res/ /poly/ /c/ /ctx/ +--+-- Sets /res/ to /poly/ divided by the scalar /c/.+foreign import ccall "ca_poly.h ca_poly_div_ca"+  ca_poly_div_ca :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /_ca_poly_divrem_basecase/ /Q/ /R/ /A/ /lenA/ /B/ /lenB/ /invB/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_divrem_basecase"+  _ca_poly_divrem_basecase :: Ptr CCa -> Ptr CCa -> Ptr CCa -> CLong -> Ptr CCa -> CLong -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_poly_divrem_basecase/ /Q/ /R/ /A/ /B/ /ctx/ +foreign import ccall "ca_poly.h ca_poly_divrem_basecase"+  ca_poly_divrem_basecase :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaCtx -> IO CInt+-- | /_ca_poly_divrem/ /Q/ /R/ /A/ /lenA/ /B/ /lenB/ /invB/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_divrem"+  _ca_poly_divrem :: Ptr CCa -> Ptr CCa -> Ptr CCa -> CLong -> Ptr CCa -> CLong -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_poly_divrem/ /Q/ /R/ /A/ /B/ /ctx/ +foreign import ccall "ca_poly.h ca_poly_divrem"+  ca_poly_divrem :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaCtx -> IO CInt+-- | /ca_poly_div/ /Q/ /A/ /B/ /ctx/ +foreign import ccall "ca_poly.h ca_poly_div"+  ca_poly_div :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaCtx -> IO CInt+-- | /ca_poly_rem/ /R/ /A/ /B/ /ctx/ +--+-- If the leading coefficient of /B/ can be proved invertible, sets /Q/ and+-- /R/ to the quotient and remainder of polynomial division of /A/ by /B/+-- and returns 1. If the leading coefficient cannot be proved invertible,+-- returns 0. The underscore method takes a precomputed inverse of the+-- leading coefficient of /B/.+foreign import ccall "ca_poly.h ca_poly_rem"+  ca_poly_rem :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaCtx -> IO CInt++-- | /_ca_poly_pow_ui_trunc/ /res/ /f/ /flen/ /exp/ /len/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_pow_ui_trunc"+  _ca_poly_pow_ui_trunc :: Ptr CCa -> Ptr CCa -> CLong -> CULong -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_poly_pow_ui_trunc/ /res/ /poly/ /exp/ /len/ /ctx/ +--+-- Sets /res/ to /poly/ raised to the power /exp/, truncated to length+-- /len/.+foreign import ccall "ca_poly.h ca_poly_pow_ui_trunc"+  ca_poly_pow_ui_trunc :: Ptr CCaPoly -> Ptr CCaPoly -> CULong -> CLong -> Ptr CCaCtx -> IO ()++-- | /_ca_poly_pow_ui/ /res/ /f/ /flen/ /exp/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_pow_ui"+  _ca_poly_pow_ui :: Ptr CCa -> Ptr CCa -> CLong -> CULong -> Ptr CCaCtx -> IO ()+-- | /ca_poly_pow_ui/ /res/ /poly/ /exp/ /ctx/ +--+-- Sets /res/ to /poly/ raised to the power /exp/.+foreign import ccall "ca_poly.h ca_poly_pow_ui"+  ca_poly_pow_ui :: Ptr CCaPoly -> Ptr CCaPoly -> CULong -> Ptr CCaCtx -> IO ()++-- Evaluation and composition --------------------------------------------------++-- | /_ca_poly_evaluate_horner/ /res/ /f/ /len/ /x/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_evaluate_horner"+  _ca_poly_evaluate_horner :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_poly_evaluate_horner/ /res/ /f/ /a/ /ctx/ +foreign import ccall "ca_poly.h ca_poly_evaluate_horner"+  ca_poly_evaluate_horner :: Ptr CCa -> Ptr CCaPoly -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /_ca_poly_evaluate/ /res/ /f/ /len/ /x/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_evaluate"+  _ca_poly_evaluate :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCa -> Ptr CCaCtx -> IO ()+-- | /ca_poly_evaluate/ /res/ /f/ /a/ /ctx/ +--+-- Sets /res/ to /f/ evaluated at the point /a/.+foreign import ccall "ca_poly.h ca_poly_evaluate"+  ca_poly_evaluate :: Ptr CCa -> Ptr CCaPoly -> Ptr CCa -> Ptr CCaCtx -> IO ()++-- | /_ca_poly_compose/ /res/ /poly1/ /len1/ /poly2/ /len2/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_compose"+  _ca_poly_compose :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_poly_compose/ /res/ /poly1/ /poly2/ /ctx/ +--+-- Sets /res/ to the composition of /poly1/ with /poly2/.+foreign import ccall "ca_poly.h ca_poly_compose"+  ca_poly_compose :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaCtx -> IO ()++-- Derivative and integral -----------------------------------------------------++-- | /_ca_poly_derivative/ /res/ /poly/ /len/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_derivative"+  _ca_poly_derivative :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_poly_derivative/ /res/ /poly/ /ctx/ +--+-- Sets /res/ to the derivative of /poly/. The underscore method needs one+-- less coefficient than /len/ for the output array.+foreign import ccall "ca_poly.h ca_poly_derivative"+  ca_poly_derivative :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaCtx -> IO ()++-- | /_ca_poly_integral/ /res/ /poly/ /len/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_integral"+  _ca_poly_integral :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_poly_integral/ /res/ /poly/ /ctx/ +--+-- Sets /res/ to the integral of /poly/. The underscore method needs one+-- more coefficient than /len/ for the output array.+foreign import ccall "ca_poly.h ca_poly_integral"+  ca_poly_integral :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaCtx -> IO ()++-- Power series division -------------------------------------------------------++-- | /_ca_poly_inv_series/ /res/ /f/ /flen/ /len/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_inv_series"+  _ca_poly_inv_series :: Ptr CCa -> Ptr CCa -> CLong -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_poly_inv_series/ /res/ /f/ /len/ /ctx/ +--+-- Sets /res/ to the power series inverse of /f/ truncated to length /len/.+foreign import ccall "ca_poly.h ca_poly_inv_series"+  ca_poly_inv_series :: Ptr CCaPoly -> Ptr CCaPoly -> CLong -> Ptr CCaCtx -> IO ()++-- | /_ca_poly_div_series/ /res/ /f/ /flen/ /g/ /glen/ /len/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_div_series"+  _ca_poly_div_series :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCa -> CLong -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_poly_div_series/ /res/ /f/ /g/ /len/ /ctx/ +--+-- Sets /res/ to the power series quotient of /f/ and /g/ truncated to+-- length /len/. This function divides by zero if /g/ has constant term+-- zero; the user should manually remove initial zeros when an exact+-- cancellation is required.+foreign import ccall "ca_poly.h ca_poly_div_series"+  ca_poly_div_series :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaPoly -> CLong -> Ptr CCaCtx -> IO ()++-- Elementary functions --------------------------------------------------------++-- | /_ca_poly_exp_series/ /res/ /f/ /flen/ /len/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_exp_series"+  _ca_poly_exp_series :: Ptr CCa -> Ptr CCa -> CLong -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_poly_exp_series/ /res/ /f/ /len/ /ctx/ +--+-- Sets /res/ to the power series exponential of /f/ truncated to length+-- /len/.+foreign import ccall "ca_poly.h ca_poly_exp_series"+  ca_poly_exp_series :: Ptr CCaPoly -> Ptr CCaPoly -> CLong -> Ptr CCaCtx -> IO ()++-- | /_ca_poly_log_series/ /res/ /f/ /flen/ /len/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_log_series"+  _ca_poly_log_series :: Ptr CCa -> Ptr CCa -> CLong -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_poly_log_series/ /res/ /f/ /len/ /ctx/ +--+-- Sets /res/ to the power series logarithm of /f/ truncated to length+-- /len/.+foreign import ccall "ca_poly.h ca_poly_log_series"+  ca_poly_log_series :: Ptr CCaPoly -> Ptr CCaPoly -> CLong -> Ptr CCaCtx -> IO ()++-- Greatest common divisor -----------------------------------------------------++-- | /_ca_poly_gcd_euclidean/ /res/ /A/ /lenA/ /B/ /lenB/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_gcd_euclidean"+  _ca_poly_gcd_euclidean :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO CLong+-- | /ca_poly_gcd_euclidean/ /res/ /A/ /B/ /ctx/ +foreign import ccall "ca_poly.h ca_poly_gcd_euclidean"+  ca_poly_gcd_euclidean :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaCtx -> IO CInt+-- | /_ca_poly_gcd/ /res/ /A/ /lenA/ /B/ /lenB/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_gcd"+  _ca_poly_gcd :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO CLong+-- | /ca_poly_gcd/ /res/ /A/ /g/ /ctx/ +--+-- Sets /res/ to the GCD of /A/ and /B/ and returns 1 on success. On+-- failure, returns 0 leaving the value of /res/ arbitrary. The computation+-- can fail if testing a leading coefficient for zero fails in the+-- execution of the GCD algorithm. The output is normalized to be monic if+-- it is not the zero polynomial.+-- +-- The underscore methods assume \(\text{lenA} \ge \text{lenB} \ge 1\), and+-- that both /A/ and /B/ have nonzero leading coefficient. They return the+-- length of the GCD, or 0 if the computation fails.+-- +-- The /euclidean/ version implements the standard Euclidean algorithm. The+-- default version first checks for rational polynomials or attempts to+-- certify numerically that the polynomials are coprime and otherwise falls+-- back to an automatic choice of algorithm (currently only the Euclidean+-- algorithm).+foreign import ccall "ca_poly.h ca_poly_gcd"+  ca_poly_gcd :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaCtx -> IO CInt++-- Roots and factorization -----------------------------------------------------++-- | /ca_poly_factor_squarefree/ /c/ /fac/ /exp/ /F/ /ctx/ +--+-- Computes the squarefree factorization of /F/, giving a product+-- \(F = c f_1 f_2^2 \ldots f_n^n\) where all \(f_i\) with \(f_i \ne 1\)+-- are squarefree and pairwise coprime. The nontrivial factors \(f_i\) are+-- written to /fac/ and the corresponding exponents are written to /exp/.+-- This algorithm can fail if GCD computation fails internally. Returns 1+-- on success and 0 on failure.+foreign import ccall "ca_poly.h ca_poly_factor_squarefree"+  ca_poly_factor_squarefree :: Ptr CCa -> Ptr CCaPolyVec -> Ptr CULong -> Ptr CCaPoly -> Ptr CCaCtx -> IO CInt++-- | /ca_poly_squarefree_part/ /res/ /poly/ /ctx/ +--+-- Sets /res/ to the squarefree part of /poly/, normalized to be monic.+-- This algorithm can fail if GCD computation fails internally. Returns 1+-- on success and 0 on failure.+foreign import ccall "ca_poly.h ca_poly_squarefree_part"+  ca_poly_squarefree_part :: Ptr CCaPoly -> Ptr CCaPoly -> Ptr CCaCtx -> IO CInt++-- | /_ca_poly_set_roots/ /poly/ /roots/ /exp/ /n/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_set_roots"+  _ca_poly_set_roots :: Ptr CCa -> Ptr CCa -> Ptr CULong -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_poly_set_roots/ /poly/ /roots/ /exp/ /ctx/ +--+-- Sets /poly/ to the monic polynomial with the /n/ roots given in the+-- vector /roots/, with multiplicities given in the vector /exp/. In other+-- words, this constructs the polynomial+-- \((x-r_0)^{e_0} (x-r_1)^{e_1} \cdots (x-r_{n-1})^{e_{n-1}}\). Uses+-- binary splitting.+foreign import ccall "ca_poly.h ca_poly_set_roots"+  ca_poly_set_roots :: Ptr CCaPoly -> Ptr CCaVec -> Ptr CULong -> Ptr CCaCtx -> IO ()++-- | /_ca_poly_roots/ /roots/ /poly/ /len/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_roots"+  _ca_poly_roots :: Ptr CCa -> Ptr CCa -> CLong -> Ptr CCaCtx -> IO CInt+-- | /ca_poly_roots/ /roots/ /exp/ /poly/ /ctx/ +--+-- Attempts to compute all complex roots of the given polynomial /poly/. On+-- success, returns 1 and sets /roots/ to a vector containing all the+-- distinct roots with corresponding multiplicities in /exp/. On failure,+-- returns 0 and leaves the values in /roots/ arbitrary. The roots are+-- returned in arbitrary order.+-- +-- Failure will occur if the leading coefficient of /poly/ cannot be proved+-- to be nonzero, if determining the correct multiplicities fails, or if+-- the builtin algorithms do not have a means to represent the roots+-- symbolically.+-- +-- The underscore method assumes that the polynomial is squarefree. The+-- non-underscore method performs a squarefree factorization.+foreign import ccall "ca_poly.h ca_poly_roots"+  ca_poly_roots :: Ptr CCaVec -> Ptr CULong -> Ptr CCaPoly -> Ptr CCaCtx -> IO CInt++-- Vectors of polynomials ------------------------------------------------------++-- | /_ca_poly_vec_init/ /len/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_vec_init"+  _ca_poly_vec_init :: CLong -> Ptr CCaCtx -> IO (Ptr CCaPoly)+-- | /ca_poly_vec_init/ /res/ /len/ /ctx/ +--+-- Initializes a vector with /len/ polynomials.+foreign import ccall "ca_poly.h ca_poly_vec_init"+  ca_poly_vec_init :: Ptr CCaPolyVec -> CLong -> Ptr CCaCtx -> IO ()++-- | /_ca_poly_vec_fit_length/ /vec/ /len/ /ctx/ +--+-- Allocates space for /len/ polynomials in /vec/.+foreign import ccall "ca_poly.h _ca_poly_vec_fit_length"+  _ca_poly_vec_fit_length :: Ptr CCaPolyVec -> CLong -> Ptr CCaCtx -> IO ()++-- | /ca_poly_vec_set_length/ /vec/ /len/ /ctx/ +--+-- Resizes /vec/ to length /len/, zero-extending if needed.+foreign import ccall "ca_poly.h ca_poly_vec_set_length"+  ca_poly_vec_set_length :: Ptr CCaPolyVec -> CLong -> Ptr CCaCtx -> IO ()++-- | /_ca_poly_vec_clear/ /vec/ /len/ /ctx/ +foreign import ccall "ca_poly.h _ca_poly_vec_clear"+  _ca_poly_vec_clear :: Ptr CCaPoly -> CLong -> Ptr CCaCtx -> IO ()+-- | /ca_poly_vec_clear/ /vec/ /ctx/ +--+-- Clears the vector /vec/.+foreign import ccall "ca_poly.h ca_poly_vec_clear"+  ca_poly_vec_clear :: Ptr CCaPolyVec -> Ptr CCaCtx -> IO ()++-- | /ca_poly_vec_append/ /vec/ /poly/ /ctx/ +--+-- Appends /poly/ to the end of the vector /vec/.+foreign import ccall "ca_poly.h ca_poly_vec_append"+  ca_poly_vec_append :: Ptr CCaPolyVec -> Ptr CCaPoly -> Ptr CCaCtx -> IO ()++++